stack-1.9.3.1/doc/0000755000000000000000000000000013455666157011745 5ustar0000000000000000stack-1.9.3.1/src/0000755000000000000000000000000013455617610011755 5ustar0000000000000000stack-1.9.3.1/src/Control/0000755000000000000000000000000013015755774013403 5ustar0000000000000000stack-1.9.3.1/src/Control/Concurrent/0000755000000000000000000000000013455617610015517 5ustar0000000000000000stack-1.9.3.1/src/Data/0000755000000000000000000000000013455617610012626 5ustar0000000000000000stack-1.9.3.1/src/Data/Aeson/0000755000000000000000000000000013455617610013673 5ustar0000000000000000stack-1.9.3.1/src/Data/Attoparsec/0000755000000000000000000000000013455617610014733 5ustar0000000000000000stack-1.9.3.1/src/Data/IORef/0000755000000000000000000000000013455617610013572 5ustar0000000000000000stack-1.9.3.1/src/Data/Monoid/0000755000000000000000000000000013344044236014046 5ustar0000000000000000stack-1.9.3.1/src/Data/Store/0000755000000000000000000000000013455617610013722 5ustar0000000000000000stack-1.9.3.1/src/Hackage/0000755000000000000000000000000013455617610013300 5ustar0000000000000000stack-1.9.3.1/src/Hackage/Security/0000755000000000000000000000000013455617610015107 5ustar0000000000000000stack-1.9.3.1/src/Hackage/Security/Client/0000755000000000000000000000000013455617610016325 5ustar0000000000000000stack-1.9.3.1/src/Hackage/Security/Client/Repository/0000755000000000000000000000000013455617610020504 5ustar0000000000000000stack-1.9.3.1/src/Hackage/Security/Client/Repository/HttpLib/0000755000000000000000000000000013455617610022052 5ustar0000000000000000stack-1.9.3.1/src/Network/0000755000000000000000000000000012535613373013406 5ustar0000000000000000stack-1.9.3.1/src/Network/HTTP/0000755000000000000000000000000013455617610014165 5ustar0000000000000000stack-1.9.3.1/src/Network/HTTP/Download/0000755000000000000000000000000013455617610015734 5ustar0000000000000000stack-1.9.3.1/src/Options/0000755000000000000000000000000012535613373013410 5ustar0000000000000000stack-1.9.3.1/src/Options/Applicative/0000755000000000000000000000000013455617610015651 5ustar0000000000000000stack-1.9.3.1/src/Options/Applicative/Builder/0000755000000000000000000000000013455617610017237 5ustar0000000000000000stack-1.9.3.1/src/Path/0000755000000000000000000000000013455617610012651 5ustar0000000000000000stack-1.9.3.1/src/Stack/0000755000000000000000000000000013455671116013023 5ustar0000000000000000stack-1.9.3.1/src/Stack/Build/0000755000000000000000000000000013455666157014073 5ustar0000000000000000stack-1.9.3.1/src/Stack/Config/0000755000000000000000000000000013455617610014227 5ustar0000000000000000stack-1.9.3.1/src/Stack/Constants/0000755000000000000000000000000013455617610014776 5ustar0000000000000000stack-1.9.3.1/src/Stack/Docker/0000755000000000000000000000000013455617610014231 5ustar0000000000000000stack-1.9.3.1/src/Stack/Ghci/0000755000000000000000000000000013312026775013672 5ustar0000000000000000stack-1.9.3.1/src/Stack/Options/0000755000000000000000000000000013455617610014455 5ustar0000000000000000stack-1.9.3.1/src/Stack/Setup/0000755000000000000000000000000013455617610014122 5ustar0000000000000000stack-1.9.3.1/src/Stack/Sig/0000755000000000000000000000000013455666157013556 5ustar0000000000000000stack-1.9.3.1/src/Stack/Types/0000755000000000000000000000000013455671116014127 5ustar0000000000000000stack-1.9.3.1/src/Stack/Types/Config/0000755000000000000000000000000013455617610015333 5ustar0000000000000000stack-1.9.3.1/src/System/0000755000000000000000000000000013455617610013241 5ustar0000000000000000stack-1.9.3.1/src/System/Process/0000755000000000000000000000000013455617610014657 5ustar0000000000000000stack-1.9.3.1/src/Text/0000755000000000000000000000000013455617610012701 5ustar0000000000000000stack-1.9.3.1/src/Text/PrettyPrint/0000755000000000000000000000000013455617610015205 5ustar0000000000000000stack-1.9.3.1/src/Text/PrettyPrint/Leijen/0000755000000000000000000000000013455671116016414 5ustar0000000000000000stack-1.9.3.1/src/main/0000755000000000000000000000000013455671116012702 5ustar0000000000000000stack-1.9.3.1/src/setup-shim/0000755000000000000000000000000013015755774014061 5ustar0000000000000000stack-1.9.3.1/src/test/0000755000000000000000000000000013455617610012734 5ustar0000000000000000stack-1.9.3.1/src/test/Network/0000755000000000000000000000000013455617610014365 5ustar0000000000000000stack-1.9.3.1/src/test/Network/HTTP/0000755000000000000000000000000013455617610015144 5ustar0000000000000000stack-1.9.3.1/src/test/Network/HTTP/Download/0000755000000000000000000000000013455617610016713 5ustar0000000000000000stack-1.9.3.1/src/test/Stack/0000755000000000000000000000000013455617610014001 5ustar0000000000000000stack-1.9.3.1/src/test/Stack/Build/0000755000000000000000000000000013455617610015040 5ustar0000000000000000stack-1.9.3.1/src/test/Stack/Ghci/0000755000000000000000000000000013312026775014651 5ustar0000000000000000stack-1.9.3.1/src/test/Stack/Types/0000755000000000000000000000000013455617610015105 5ustar0000000000000000stack-1.9.3.1/src/test/Stack/Untar/0000755000000000000000000000000013455711513015067 5ustar0000000000000000stack-1.9.3.1/src/unix/0000755000000000000000000000000013455617610012740 5ustar0000000000000000stack-1.9.3.1/src/unix/Stack/0000755000000000000000000000000013455617610014005 5ustar0000000000000000stack-1.9.3.1/src/unix/System/0000755000000000000000000000000013455617610014224 5ustar0000000000000000stack-1.9.3.1/src/windows/0000755000000000000000000000000013455617610013447 5ustar0000000000000000stack-1.9.3.1/src/windows/Stack/0000755000000000000000000000000013455617610014514 5ustar0000000000000000stack-1.9.3.1/src/windows/System/0000755000000000000000000000000013455617610014733 5ustar0000000000000000stack-1.9.3.1/test/0000755000000000000000000000000013015755774012153 5ustar0000000000000000stack-1.9.3.1/test/integration/0000755000000000000000000000000013455617610014470 5ustar0000000000000000stack-1.9.3.1/test/integration/lib/0000755000000000000000000000000013455617610015236 5ustar0000000000000000stack-1.9.3.1/test/package-dump/0000755000000000000000000000000013015755774014511 5ustar0000000000000000stack-1.9.3.1/src/Control/Concurrent/Execute.hs0000644000000000000000000001356413455617610017466 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude #-} {-# LANGUAGE DeriveDataTypeable #-} {-# LANGUAGE RecordWildCards #-} -- Concurrent execution with dependencies. Types currently hard-coded for needs -- of stack, but could be generalized easily. module Control.Concurrent.Execute ( ActionType (..) , ActionId (..) , ActionContext (..) , Action (..) , Concurrency(..) , runActions ) where import Control.Concurrent.STM (retry) import Stack.Prelude import Data.List (sortBy) import qualified Data.Set as Set import Stack.Types.PackageIdentifier data ActionType = ATBuild -- ^ Action for building a package's library and executables. If -- 'taskAllInOne' is 'True', then this will also build benchmarks -- and tests. It is 'False' when then library's benchmarks or -- test-suites have cyclic dependencies. | ATBuildFinal -- ^ Task for building the package's benchmarks and test-suites. -- Requires that the library was already built. | ATRunTests -- ^ Task for running the package's test-suites. | ATRunBenchmarks -- ^ Task for running the package's benchmarks. deriving (Show, Eq, Ord) data ActionId = ActionId !PackageIdentifier !ActionType deriving (Show, Eq, Ord) data Action = Action { actionId :: !ActionId , actionDeps :: !(Set ActionId) , actionDo :: !(ActionContext -> IO ()) , actionConcurrency :: !Concurrency } data Concurrency = ConcurrencyAllowed | ConcurrencyDisallowed deriving (Eq) data ActionContext = ActionContext { acRemaining :: !(Set ActionId) -- ^ Does not include the current action , acDownstream :: [Action] -- ^ Actions which depend on the current action , acConcurrency :: !Concurrency -- ^ Whether this action may be run concurrently with others } data ExecuteState = ExecuteState { esActions :: TVar [Action] , esExceptions :: TVar [SomeException] , esInAction :: TVar (Set ActionId) , esCompleted :: TVar Int , esKeepGoing :: Bool } data ExecuteException = InconsistentDependencies deriving Typeable instance Exception ExecuteException instance Show ExecuteException where show InconsistentDependencies = "Inconsistent dependencies were discovered while executing your build plan. This should never happen, please report it as a bug to the stack team." runActions :: Int -- ^ threads -> Bool -- ^ keep going after one task has failed -> [Action] -> (TVar Int -> TVar (Set ActionId) -> IO ()) -- ^ progress updated -> IO [SomeException] runActions threads keepGoing actions0 withProgress = do es <- ExecuteState <$> newTVarIO (sortActions actions0) <*> newTVarIO [] <*> newTVarIO Set.empty <*> newTVarIO 0 <*> pure keepGoing _ <- async $ withProgress (esCompleted es) (esInAction es) if threads <= 1 then runActions' es else replicateConcurrently_ threads $ runActions' es readTVarIO $ esExceptions es -- | Sort actions such that those that can't be run concurrently are at -- the end. sortActions :: [Action] -> [Action] sortActions = sortBy (compareConcurrency `on` actionConcurrency) where -- NOTE: Could derive Ord. However, I like to make this explicit so -- that changes to the datatype must consider how it's affecting -- this. compareConcurrency ConcurrencyAllowed ConcurrencyDisallowed = LT compareConcurrency ConcurrencyDisallowed ConcurrencyAllowed = GT compareConcurrency _ _ = EQ runActions' :: ExecuteState -> IO () runActions' ExecuteState {..} = loop where breakOnErrs inner = do errs <- readTVar esExceptions if null errs || esKeepGoing then inner else return $ return () withActions inner = do as <- readTVar esActions if null as then return $ return () else inner as loop = join $ atomically $ breakOnErrs $ withActions $ \as -> case break (Set.null . actionDeps) as of (_, []) -> do inAction <- readTVar esInAction if Set.null inAction then do unless esKeepGoing $ modifyTVar esExceptions (toException InconsistentDependencies:) return $ return () else retry (xs, action:ys) -> do inAction <- readTVar esInAction case actionConcurrency action of ConcurrencyAllowed -> return () ConcurrencyDisallowed -> unless (Set.null inAction) retry let as' = xs ++ ys remaining = Set.union (Set.fromList $ map actionId as') inAction writeTVar esActions as' modifyTVar esInAction (Set.insert $ actionId action) return $ mask $ \restore -> do eres <- try $ restore $ actionDo action ActionContext { acRemaining = remaining , acDownstream = downstreamActions (actionId action) as' , acConcurrency = actionConcurrency action } atomically $ do modifyTVar esInAction (Set.delete $ actionId action) modifyTVar esCompleted (+1) case eres of Left err -> modifyTVar esExceptions (err:) Right () -> let dropDep a = a { actionDeps = Set.delete (actionId action) $ actionDeps a } in modifyTVar esActions $ map dropDep restore loop downstreamActions :: ActionId -> [Action] -> [Action] downstreamActions aid = filter (\a -> aid `Set.member` actionDeps a) stack-1.9.3.1/src/Data/Aeson/Extended.hs0000644000000000000000000001333213455617610015771 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude #-} {-# LANGUAGE DeriveGeneric #-} {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TupleSections #-} -- | Extensions to Aeson parsing of objects. module Data.Aeson.Extended ( module Export -- * Extended failure messages , (.:) , (.:?) -- * JSON Parser that emits warnings , JSONWarning (..) , WarningParser , WithJSONWarnings (..) , withObjectWarnings , jsonSubWarnings , jsonSubWarningsT , jsonSubWarningsTT , logJSONWarnings , noJSONWarnings , tellJSONField , unWarningParser , (..:) , (..:?) , (..!=) ) where import Control.Monad.Trans.Writer.Strict (WriterT, mapWriterT, runWriterT, tell) import Data.Aeson as Export hiding ((.:), (.:?)) import qualified Data.Aeson as A import Data.Aeson.Types hiding ((.:), (.:?)) import qualified Data.HashMap.Strict as HashMap import qualified Data.Set as Set import Data.Text (unpack) import qualified Data.Text as T import Generics.Deriving.Monoid (mappenddefault, memptydefault) import Stack.Prelude -- | Extends @.:@ warning to include field name. (.:) :: FromJSON a => Object -> Text -> Parser a (.:) o p = modifyFailure (("failed to parse field '" <> unpack p <> "': ") <>) (o A..: p) {-# INLINE (.:) #-} -- | Extends @.:?@ warning to include field name. (.:?) :: FromJSON a => Object -> Text -> Parser (Maybe a) (.:?) o p = modifyFailure (("failed to parse field '" <> unpack p <> "': ") <>) (o A..:? p) {-# INLINE (.:?) #-} -- | 'WarningParser' version of @.:@. (..:) :: FromJSON a => Object -> Text -> WarningParser a o ..: k = tellJSONField k >> lift (o .: k) -- | 'WarningParser' version of @.:?@. (..:?) :: FromJSON a => Object -> Text -> WarningParser (Maybe a) o ..:? k = tellJSONField k >> lift (o .:? k) -- | 'WarningParser' version of @.!=@. (..!=) :: WarningParser (Maybe a) -> a -> WarningParser a wp ..!= d = flip mapWriterT wp $ \p -> do a <- fmap snd p fmap (, a) (fmap fst p .!= d) -- | Tell warning parser about an expected field, so it doesn't warn about it. tellJSONField :: Text -> WarningParser () tellJSONField key = tell (mempty { wpmExpectedFields = Set.singleton key}) -- | 'WarningParser' version of 'withObject'. withObjectWarnings :: String -> (Object -> WarningParser a) -> Value -> Parser (WithJSONWarnings a) withObjectWarnings expected f = withObject expected $ \obj -> do (a,w) <- runWriterT (f obj) let unrecognizedFields = Set.toList (Set.difference (Set.fromList (HashMap.keys obj)) (wpmExpectedFields w)) return (WithJSONWarnings a (wpmWarnings w ++ case unrecognizedFields of [] -> [] _ -> [JSONUnrecognizedFields expected unrecognizedFields])) -- | Convert a 'WarningParser' to a 'Parser'. unWarningParser :: WarningParser a -> Parser a unWarningParser wp = do (a,_) <- runWriterT wp return a -- | Log JSON warnings. logJSONWarnings :: (MonadReader env m, HasLogFunc env, HasCallStack, MonadIO m) => FilePath -> [JSONWarning] -> m () logJSONWarnings fp = mapM_ (\w -> logWarn ("Warning: " <> fromString fp <> ": " <> displayShow w)) -- | Handle warnings in a sub-object. jsonSubWarnings :: WarningParser (WithJSONWarnings a) -> WarningParser a jsonSubWarnings f = do WithJSONWarnings result warnings <- f tell (mempty { wpmWarnings = warnings }) return result -- | Handle warnings in a @Traversable@ of sub-objects. jsonSubWarningsT :: Traversable t => WarningParser (t (WithJSONWarnings a)) -> WarningParser (t a) jsonSubWarningsT f = mapM (jsonSubWarnings . return) =<< f -- | Handle warnings in a @Maybe Traversable@ of sub-objects. jsonSubWarningsTT :: (Traversable t, Traversable u) => WarningParser (u (t (WithJSONWarnings a))) -> WarningParser (u (t a)) jsonSubWarningsTT f = mapM (jsonSubWarningsT . return) =<< f -- Parsed JSON value without any warnings noJSONWarnings :: a -> WithJSONWarnings a noJSONWarnings v = WithJSONWarnings v [] -- | JSON parser that warns about unexpected fields in objects. type WarningParser a = WriterT WarningParserMonoid Parser a -- | Monoid used by 'WarningParser' to track expected fields and warnings. data WarningParserMonoid = WarningParserMonoid { wpmExpectedFields :: !(Set Text) , wpmWarnings :: [JSONWarning] } deriving Generic instance Semigroup WarningParserMonoid where (<>) = mappenddefault instance Monoid WarningParserMonoid where mempty = memptydefault mappend = (<>) instance IsString WarningParserMonoid where fromString s = mempty { wpmWarnings = [fromString s] } -- Parsed JSON value with its warnings data WithJSONWarnings a = WithJSONWarnings a [JSONWarning] deriving (Eq, Generic, Show) instance Functor WithJSONWarnings where fmap f (WithJSONWarnings x w) = WithJSONWarnings (f x) w instance Monoid a => Semigroup (WithJSONWarnings a) where (<>) = mappenddefault instance Monoid a => Monoid (WithJSONWarnings a) where mempty = memptydefault mappend = (<>) -- | Warning output from 'WarningParser'. data JSONWarning = JSONUnrecognizedFields String [Text] | JSONGeneralWarning !Text deriving Eq instance Show JSONWarning where show (JSONUnrecognizedFields obj [field]) = "Unrecognized field in " <> obj <> ": " <> T.unpack field show (JSONUnrecognizedFields obj fields) = "Unrecognized fields in " <> obj <> ": " <> T.unpack (T.intercalate ", " fields) show (JSONGeneralWarning t) = T.unpack t instance IsString JSONWarning where fromString = JSONGeneralWarning . T.pack stack-1.9.3.1/src/Data/Attoparsec/Args.hs0000644000000000000000000000273413312026775016167 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude #-} {-# LANGUAGE OverloadedStrings #-} -- | Parsing of stack command line arguments module Data.Attoparsec.Args ( EscapingMode(..) , argsParser , parseArgs , parseArgsFromString ) where import Data.Attoparsec.Text (()) import qualified Data.Attoparsec.Text as P import qualified Data.Text as T import Stack.Prelude -- | Mode for parsing escape characters. data EscapingMode = Escaping | NoEscaping deriving (Show,Eq,Enum) -- | Parse arguments using 'argsParser'. parseArgs :: EscapingMode -> Text -> Either String [String] parseArgs mode = P.parseOnly (argsParser mode) -- | Parse using 'argsParser' from a string. parseArgsFromString :: EscapingMode -> String -> Either String [String] parseArgsFromString mode = P.parseOnly (argsParser mode) . T.pack -- | A basic argument parser. It supports space-separated text, and -- string quotation with identity escaping: \x -> x. argsParser :: EscapingMode -> P.Parser [String] argsParser mode = many (P.skipSpace *> (quoted <|> unquoted)) <* P.skipSpace <* (P.endOfInput "unterminated string") where unquoted = P.many1 naked quoted = P.char '"' *> string <* P.char '"' string = many (case mode of Escaping -> escaped <|> nonquote NoEscaping -> nonquote) escaped = P.char '\\' *> P.anyChar nonquote = P.satisfy (/= '"') naked = P.satisfy (not . flip elem ("\" " :: String)) stack-1.9.3.1/src/Data/Attoparsec/Combinators.hs0000644000000000000000000000116313312026775017546 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude #-} -- | More readable combinators for writing parsers. module Data.Attoparsec.Combinators where import Stack.Prelude -- | Concatenate two parsers. appending :: (Applicative f,Semigroup a) => f a -> f a -> f a appending a b = (<>) <$> a <*> b -- | Alternative parsers. alternating :: Alternative f => f a -> f a -> f a alternating a b = a <|> b -- | Pure something. pured :: (Applicative g,Applicative f) => g a -> g (f a) pured = fmap pure -- | Concatting the result of an action. concating :: (Monoid m,Applicative f) => f [m] -> f m concating = fmap mconcat stack-1.9.3.1/src/Data/Attoparsec/Interpreter.hs0000644000000000000000000001355513455617610017603 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude #-} {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE CPP #-} {- | This module implements parsing of additional arguments embedded in a comment when stack is invoked as a script interpreter ===Specifying arguments in script interpreter mode @/stack/@ can execute a Haskell source file using @/runghc/@ and if required it can also install and setup the compiler and any package dependencies automatically. For using a Haskell source file as an executable script on a Unix like OS, the first line of the file must specify @stack@ as the interpreter using a shebang directive e.g. > #!/usr/bin/env stack Additional arguments can be specified in a haskell comment following the @#!@ line. The contents inside the comment must be a single valid stack command line, starting with @stack@ as the command and followed by the options to use for executing this file. The comment must be on the line immediately following the @#!@ line. The comment must start in the first column of the line. When using a block style comment the command can be split on multiple lines. Here is an example of a single line comment: > #!/usr/bin/env stack > -- stack --resolver lts-3.14 --install-ghc runghc --package random Here is an example of a multi line block comment: @ #!\/usr\/bin\/env stack {\- stack --resolver lts-3.14 --install-ghc runghc --package random -\} @ When the @#!@ line is not present, the file can still be executed using @stack \@ command if the file starts with a valid stack interpreter comment. This can be used to execute the file on Windows for example. Nested block comments are not supported. -} module Data.Attoparsec.Interpreter ( interpreterArgsParser -- for unit tests , getInterpreterArgs ) where import Data.Attoparsec.Args import Data.Attoparsec.Text (()) import qualified Data.Attoparsec.Text as P import Data.Char (isSpace) import Data.Conduit import Data.Conduit.Attoparsec import Data.Conduit.Text (decodeUtf8) import Data.List (intercalate) import Data.Text (pack) import Stack.Constants import Stack.Prelude import System.FilePath (takeExtension) import System.IO (stderr, hPutStrLn) -- | Parser to extract the stack command line embedded inside a comment -- after validating the placement and formatting rules for a valid -- interpreter specification. interpreterArgsParser :: Bool -> String -> P.Parser String interpreterArgsParser isLiterate progName = P.option "" sheBangLine *> interpreterComment where sheBangLine = P.string "#!" *> P.manyTill P.anyChar P.endOfLine commentStart psr = (psr (progName ++ " options comment")) *> P.skipSpace *> (P.string (pack progName) show progName) -- Treat newlines as spaces inside the block comment anyCharNormalizeSpace = let normalizeSpace c = if isSpace c then ' ' else c in P.satisfyWith normalizeSpace $ const True comment start end = commentStart start *> ((end >> return "") <|> (P.space *> (P.manyTill anyCharNormalizeSpace end "-}"))) horizontalSpace = P.satisfy P.isHorizontalSpace lineComment = comment "--" (P.endOfLine <|> P.endOfInput) literateLineComment = comment (">" *> horizontalSpace *> "--") (P.endOfLine <|> P.endOfInput) blockComment = comment "{-" (P.string "-}") literateBlockComment = (">" *> horizontalSpace *> "{-") *> P.skipMany (("" <$ horizontalSpace) <|> (P.endOfLine *> ">")) *> (P.string (pack progName) progName) *> P.manyTill' (P.satisfy (not . P.isEndOfLine) <|> (' ' <$ (P.endOfLine *> ">" ">"))) "-}" interpreterComment = if isLiterate then literateLineComment <|> literateBlockComment else lineComment <|> blockComment -- | Extract stack arguments from a correctly placed and correctly formatted -- comment when it is being used as an interpreter getInterpreterArgs :: String -> IO [String] getInterpreterArgs file = do eArgStr <- withSourceFile file parseFile case eArgStr of Left err -> handleFailure $ decodeError err Right str -> parseArgStr str where parseFile src = runConduit $ src .| decodeUtf8 .| sinkParserEither (interpreterArgsParser isLiterate stackProgName) isLiterate = takeExtension file == ".lhs" -- FIXME We should print anything only when explicit verbose mode is -- specified by the user on command line. But currently the -- implementation does not accept or parse any command line flags in -- interpreter mode. We can only invoke the interpreter as -- "stack " strictly without any options. stackWarn s = hPutStrLn stderr $ stackProgName ++ ": WARNING! " ++ s handleFailure err = do mapM_ stackWarn (lines err) stackWarn "Missing or unusable stack options specification" stackWarn "Using runghc without any additional stack options" return ["runghc"] parseArgStr str = case P.parseOnly (argsParser Escaping) (pack str) of Left err -> handleFailure ("Error parsing command specified in the " ++ "stack options comment: " ++ err) Right [] -> handleFailure "Empty argument list in stack options comment" Right args -> return args decodeError e = case e of #if MIN_VERSION_conduit_extra(1,2,0) ParseError ctxs _ (Position line col _) -> #else ParseError ctxs _ (Position line col) -> #endif if null ctxs then "Parse error" else ("Expecting " ++ intercalate " or " ctxs) ++ " at line " ++ show line ++ ", column " ++ show col DivergentParser -> "Divergent parser" stack-1.9.3.1/src/Data/IORef/RunOnce.hs0000644000000000000000000000071213455617610015477 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude #-} module Data.IORef.RunOnce (runOnce) where import Stack.Prelude runOnce :: (MonadUnliftIO m, MonadIO n) => m a -> m (n a) runOnce f = withRunInIO $ \run -> do ref <- newIORef Nothing return $ liftIO $ do mval <- readIORef ref case mval of Just val -> return val Nothing -> do val <- run f writeIORef ref (Just val) return val stack-1.9.3.1/src/Data/Monoid/Map.hs0000644000000000000000000000113613344044236015120 0ustar0000000000000000{-# LANGUAGE DeriveGeneric #-} {-# LANGUAGE GeneralizedNewtypeDeriving #-} module Data.Monoid.Map where import qualified Data.Map as M import Stack.Prelude -- | Utility newtype wrapper to make make Map's Monoid also use the -- element's Monoid. newtype MonoidMap k a = MonoidMap (Map k a) deriving (Eq, Ord, Read, Show, Generic, Functor) instance (Ord k, Semigroup a) => Semigroup (MonoidMap k a) where MonoidMap mp1 <> MonoidMap mp2 = MonoidMap (M.unionWith (<>) mp1 mp2) instance (Ord k, Semigroup a) => Monoid (MonoidMap k a) where mappend = (<>) mempty = MonoidMap mempty stack-1.9.3.1/src/Data/Store/VersionTagged.hs0000644000000000000000000001053013455617610017016 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude #-} {-# LANGUAGE DeriveDataTypeable #-} {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE TemplateHaskell #-} {-# LANGUAGE ConstraintKinds #-} {-# LANGUAGE FlexibleContexts #-} {-# LANGUAGE ViewPatterns #-} -- | Tag a Store instance with structural version info to ensure we're -- reading a compatible format. module Data.Store.VersionTagged ( versionedEncodeFile , versionedDecodeOrLoad , versionedDecodeFile , storeVersionConfig ) where import Stack.Prelude import qualified Data.ByteString as BS import qualified Data.Map as M import qualified Data.Set as S import Data.Store import Data.Store.Core (unsafeEncodeWith) import Data.Store.Version import Language.Haskell.TH import Path import Path.IO (ensureDir) versionedEncodeFile :: Data a => VersionConfig a -> Q Exp versionedEncodeFile vc = [e| storeEncodeFile $(encodeWithVersionQ vc) $(decodeWithVersionQ vc) |] versionedDecodeOrLoad :: Data a => VersionConfig a -> Q Exp versionedDecodeOrLoad vc = [| versionedDecodeOrLoadImpl $(encodeWithVersionQ vc) $(decodeWithVersionQ vc) |] versionedDecodeFile :: Data a => VersionConfig a -> Q Exp versionedDecodeFile vc = [e| versionedDecodeFileImpl $(decodeWithVersionQ vc) |] -- | Write to the given file. storeEncodeFile :: (Store a, MonadIO m, MonadReader env m, HasCallStack, HasLogFunc env, Eq a) => (a -> (Int, Poke ())) -> Peek a -> Path Abs File -> a -> m () storeEncodeFile pokeFunc peekFunc fp x = do let fpt = fromString (toFilePath fp) logDebug $ "Encoding " <> fpt ensureDir (parent fp) let (sz, poker) = pokeFunc x encoded = unsafeEncodeWith poker sz assert (decodeExWith peekFunc encoded == x) $ liftIO $ BS.writeFile (toFilePath fp) encoded logDebug $ "Finished writing " <> fpt -- | Read from the given file. If the read fails, run the given action and -- write that back to the file. Always starts the file off with the -- version tag. versionedDecodeOrLoadImpl :: (Store a, Eq a, MonadUnliftIO m, MonadReader env m, HasCallStack, HasLogFunc env) => (a -> (Int, Poke ())) -> Peek a -> Path Abs File -> m a -> m a versionedDecodeOrLoadImpl pokeFunc peekFunc fp mx = do let fpt = fromString (toFilePath fp) logDebug $ "Trying to decode " <> fpt mres <- versionedDecodeFileImpl peekFunc fp case mres of Just x -> do logDebug $ "Success decoding " <> fpt return x _ -> do logDebug $ "Failure decoding " <> fpt x <- mx storeEncodeFile pokeFunc peekFunc fp x return x versionedDecodeFileImpl :: (Store a, MonadUnliftIO m, MonadReader env m, HasCallStack, HasLogFunc env) => Peek a -> Path loc File -> m (Maybe a) versionedDecodeFileImpl peekFunc fp = do mbs <- liftIO (Just <$> BS.readFile (toFilePath fp)) `catch` \(err :: IOException) -> do logDebug ("Exception ignored when attempting to load " <> fromString (toFilePath fp) <> ": " <> displayShow err) return Nothing case mbs of Nothing -> return Nothing Just bs -> liftIO (Just <$> decodeIOWith peekFunc bs) `catch` \(err :: PeekException) -> do let fpt = fromString (toFilePath fp) logDebug ("Error while decoding " <> fpt <> ": " <> displayShow err <> " (this might not be an error, when switching between stack versions)") return Nothing storeVersionConfig :: String -> String -> VersionConfig a storeVersionConfig name hash = (namedVersionConfig name hash) { vcIgnore = S.fromList [ "Data.Vector.Unboxed.Base.Vector GHC.Types.Word" , "Data.ByteString.Internal.ByteString" ] , vcRenames = M.fromList [ ( "Data.Maybe.Maybe", "GHC.Base.Maybe") , ( "Stack.Types.Compiler.CVActual" , "Stack.Types.Compiler.'CVActual" ) , ( "Stack.Types.Compiler.CVWanted" , "Stack.Types.Compiler.'CVWanted" ) -- moved in containers 0.5.9.1 , ( "Data.Map.Internal.Map", "Data.Map.Base.Map") , ( "Data.Set.Internal.Set", "Data.Set.Base.Set") ] } stack-1.9.3.1/src/Network/HTTP/Download.hs0000644000000000000000000001126213455617610016272 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude #-} {-# LANGUAGE DeriveDataTypeable #-} {-# LANGUAGE MultiParamTypeClasses #-} {-# LANGUAGE OverloadedStrings #-} module Network.HTTP.Download ( verifiedDownload , DownloadRequest(..) , drRetryPolicyDefault , HashCheck(..) , DownloadException(..) , CheckHexDigest(..) , LengthCheck , VerifiedDownloadException(..) , download , redownload , httpJSON , httpLbs , httpLBS , parseRequest , parseUrlThrow , setGithubHeaders , withResponse ) where import Stack.Prelude import Stack.Types.Runner import qualified Data.ByteString.Lazy as L import Data.Conduit (yield) import qualified Data.Conduit.Binary as CB import Data.Text.Encoding.Error (lenientDecode) import Data.Text.Encoding (decodeUtf8With) import Network.HTTP.Download.Verified import Network.HTTP.StackClient (Request, Response, HttpException, httpJSON, httpLbs, httpLBS, withResponse, path, checkResponse, parseUrlThrow, parseRequest, setRequestHeader, getResponseHeaders, requestHeaders, getResponseBody, getResponseStatusCode) import Path.IO (doesFileExist) import System.Directory (createDirectoryIfMissing, removeFile) import System.FilePath (takeDirectory, (<.>)) -- | Download the given URL to the given location. If the file already exists, -- no download is performed. Otherwise, creates the parent directory, downloads -- to a temporary file, and on file download completion moves to the -- appropriate destination. -- -- Throws an exception if things go wrong download :: HasRunner env => Request -> Path Abs File -- ^ destination -> RIO env Bool -- ^ Was a downloaded performed (True) or did the file already exist (False)? download req destpath = do let downloadReq = DownloadRequest { drRequest = req , drHashChecks = [] , drLengthCheck = Nothing , drRetryPolicy = drRetryPolicyDefault } let progressHook _ = return () verifiedDownload downloadReq destpath progressHook -- | Same as 'download', but will download a file a second time if it is already present. -- -- Returns 'True' if the file was downloaded, 'False' otherwise redownload :: HasRunner env => Request -> Path Abs File -- ^ destination -> RIO env Bool redownload req0 dest = do logDebug $ "Downloading " <> display (decodeUtf8With lenientDecode (path req0)) let destFilePath = toFilePath dest etagFilePath = destFilePath <.> "etag" metag <- do exists <- doesFileExist dest if not exists then return Nothing else liftIO $ handleIO (const $ return Nothing) $ fmap Just $ withSourceFile etagFilePath $ \src -> runConduit $ src .| CB.take 512 let req1 = case metag of Nothing -> req0 Just etag -> req0 { requestHeaders = requestHeaders req0 ++ [("If-None-Match", L.toStrict etag)] } req2 = req1 { checkResponse = \_ _ -> return () } recoveringHttp drRetryPolicyDefault $ catchingHttpExceptions $ liftIO $ withResponse req2 $ \res -> case getResponseStatusCode res of 200 -> do createDirectoryIfMissing True $ takeDirectory destFilePath -- Order here is important: first delete the etag, then write the -- file, then write the etag. That way, if any step fails, it will -- force the download to happen again. handleIO (const $ return ()) $ removeFile etagFilePath withSinkFileCautious destFilePath $ \sink -> runConduit $ getResponseBody res .| sink forM_ (lookup "ETag" (getResponseHeaders res)) $ \e -> withSinkFileCautious etagFilePath $ \sink -> runConduit $ yield e .| sink return True 304 -> return False _ -> throwM $ RedownloadInvalidResponse req2 dest $ void res where catchingHttpExceptions :: RIO env a -> RIO env a catchingHttpExceptions action = catch action (throwM . RedownloadHttpError) data DownloadException = RedownloadInvalidResponse Request (Path Abs File) (Response ()) | RedownloadHttpError HttpException deriving (Show, Typeable) instance Exception DownloadException -- | Set the user-agent request header setGithubHeaders :: Request -> Request setGithubHeaders = setRequestHeader "Accept" ["application/vnd.github.v3+json"] stack-1.9.3.1/src/Network/HTTP/Download/Verified.hs0000644000000000000000000003131013455617610020023 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude #-} {-# LANGUAGE CPP #-} {-# LANGUAGE DeriveDataTypeable #-} {-# LANGUAGE MultiParamTypeClasses #-} {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE RecordWildCards #-} {-# LANGUAGE RankNTypes #-} {-# LANGUAGE GADTs #-} {-# LANGUAGE StandaloneDeriving #-} module Network.HTTP.Download.Verified ( verifiedDownload , recoveringHttp , DownloadRequest(..) , drRetryPolicyDefault , HashCheck(..) , CheckHexDigest(..) , LengthCheck , VerifiedDownloadException(..) ) where import qualified Data.List as List import qualified Data.ByteString as ByteString import qualified Data.ByteString.Base64 as B64 import qualified Data.Conduit.Binary as CB import qualified Data.Conduit.List as CL import qualified Data.Text as Text import qualified Data.Text.Encoding as Text import Control.Monad import Control.Monad.Catch (Handler (..)) -- would be nice if retry exported this itself import Stack.Prelude hiding (Handler (..)) import Control.Retry (recovering,limitRetries,RetryPolicy,exponentialBackoff,RetryStatus(..)) import Crypto.Hash import Crypto.Hash.Conduit (sinkHash) import Data.ByteArray as Mem (convert) import Data.ByteArray.Encoding as Mem (convertToBase, Base(Base16)) import Data.ByteString.Char8 (readInteger) import Data.Conduit import Data.Conduit.Binary (sourceHandle) import Data.Text.Encoding (decodeUtf8With) import Data.Text.Encoding.Error (lenientDecode) import GHC.IO.Exception (IOException(..),IOErrorType(..)) import Network.HTTP.StackClient (Request, HttpException, httpSink, getUri, path, getResponseHeaders, hContentLength, hContentMD5) import Path import Stack.Types.Runner import Stack.PrettyPrint import System.Directory import qualified System.FilePath as FP ((<.>)) -- | A request together with some checks to perform. data DownloadRequest = DownloadRequest { drRequest :: Request , drHashChecks :: [HashCheck] , drLengthCheck :: Maybe LengthCheck , drRetryPolicy :: RetryPolicy } -- | Default to retrying seven times with exponential backoff starting from -- one hundred milliseconds. -- -- This means the tries will occur after these delays if necessary: -- -- * 0.1s -- * 0.2s -- * 0.4s -- * 0.8s -- * 1.6s -- * 3.2s -- * 6.4s drRetryPolicyDefault :: RetryPolicy drRetryPolicyDefault = limitRetries 7 <> exponentialBackoff onehundredMilliseconds where onehundredMilliseconds = 100000 data HashCheck = forall a. (Show a, HashAlgorithm a) => HashCheck { hashCheckAlgorithm :: a , hashCheckHexDigest :: CheckHexDigest } deriving instance Show HashCheck data CheckHexDigest = CheckHexDigestString String | CheckHexDigestByteString ByteString | CheckHexDigestHeader ByteString deriving Show instance IsString CheckHexDigest where fromString = CheckHexDigestString type LengthCheck = Int -- | An exception regarding verification of a download. data VerifiedDownloadException = WrongContentLength Request Int -- expected ByteString -- actual (as listed in the header) | WrongStreamLength Request Int -- expected Int -- actual | WrongDigest Request String -- algorithm CheckHexDigest -- expected String -- actual (shown) deriving (Typeable) instance Show VerifiedDownloadException where show (WrongContentLength req expected actual) = "Download expectation failure: ContentLength header\n" ++ "Expected: " ++ show expected ++ "\n" ++ "Actual: " ++ displayByteString actual ++ "\n" ++ "For: " ++ show (getUri req) show (WrongStreamLength req expected actual) = "Download expectation failure: download size\n" ++ "Expected: " ++ show expected ++ "\n" ++ "Actual: " ++ show actual ++ "\n" ++ "For: " ++ show (getUri req) show (WrongDigest req algo expected actual) = "Download expectation failure: content hash (" ++ algo ++ ")\n" ++ "Expected: " ++ displayCheckHexDigest expected ++ "\n" ++ "Actual: " ++ actual ++ "\n" ++ "For: " ++ show (getUri req) instance Exception VerifiedDownloadException -- This exception is always caught and never thrown outside of this module. data VerifyFileException = WrongFileSize Int -- expected Integer -- actual (as listed by hFileSize) deriving (Show, Typeable) instance Exception VerifyFileException -- Show a ByteString that is known to be UTF8 encoded. displayByteString :: ByteString -> String displayByteString = Text.unpack . Text.strip . Text.decodeUtf8 -- Show a CheckHexDigest in human-readable format. displayCheckHexDigest :: CheckHexDigest -> String displayCheckHexDigest (CheckHexDigestString s) = s ++ " (String)" displayCheckHexDigest (CheckHexDigestByteString s) = displayByteString s ++ " (ByteString)" displayCheckHexDigest (CheckHexDigestHeader h) = show (B64.decodeLenient h) ++ " (Header. unencoded: " ++ show h ++ ")" -- | Make sure that the hash digest for a finite stream of bytes -- is as expected. -- -- Throws WrongDigest (VerifiedDownloadException) sinkCheckHash :: MonadThrow m => Request -> HashCheck -> ConduitM ByteString o m () sinkCheckHash req HashCheck{..} = do digest <- sinkHashUsing hashCheckAlgorithm let actualDigestString = show digest let actualDigestHexByteString = Mem.convertToBase Mem.Base16 digest let actualDigestBytes = Mem.convert digest let passedCheck = case hashCheckHexDigest of CheckHexDigestString s -> s == actualDigestString CheckHexDigestByteString b -> b == actualDigestHexByteString CheckHexDigestHeader b -> B64.decodeLenient b == actualDigestHexByteString || B64.decodeLenient b == actualDigestBytes -- A hack to allow hackage tarballs to download. -- They should really base64-encode their md5 header as per rfc2616#sec14.15. -- https://github.com/commercialhaskell/stack/issues/240 || b == actualDigestHexByteString unless passedCheck $ throwM $ WrongDigest req (show hashCheckAlgorithm) hashCheckHexDigest actualDigestString assertLengthSink :: MonadThrow m => Request -> LengthCheck -> ZipSink ByteString m () assertLengthSink req expectedStreamLength = ZipSink $ do Sum actualStreamLength <- CL.foldMap (Sum . ByteString.length) when (actualStreamLength /= expectedStreamLength) $ throwM $ WrongStreamLength req expectedStreamLength actualStreamLength -- | A more explicitly type-guided sinkHash. sinkHashUsing :: (Monad m, HashAlgorithm a) => a -> ConduitM ByteString o m (Digest a) sinkHashUsing _ = sinkHash -- | Turns a list of hash checks into a ZipSink that checks all of them. hashChecksToZipSink :: MonadThrow m => Request -> [HashCheck] -> ZipSink ByteString m () hashChecksToZipSink req = traverse_ (ZipSink . sinkCheckHash req) -- 'Control.Retry.recovering' customized for HTTP failures recoveringHttp :: forall env a. HasRunner env => RetryPolicy -> RIO env a -> RIO env a recoveringHttp retryPolicy = #if MIN_VERSION_retry(0,7,0) helper $ \run -> recovering retryPolicy (handlers run) . const #else helper $ \run -> recovering retryPolicy (handlers run) #endif where helper :: (UnliftIO (RIO env) -> IO a -> IO a) -> RIO env a -> RIO env a helper wrapper action = withUnliftIO $ \run -> wrapper run (unliftIO run action) handlers :: UnliftIO (RIO env) -> [RetryStatus -> Handler IO Bool] handlers u = [Handler . alwaysRetryHttp u,const $ Handler retrySomeIO] alwaysRetryHttp :: UnliftIO (RIO env) -> RetryStatus -> HttpException -> IO Bool alwaysRetryHttp u rs _ = do unliftIO u $ prettyWarn $ vcat [ flow $ unwords [ "Retry number" , show (rsIterNumber rs) , "after a total delay of" , show (rsCumulativeDelay rs) , "us" ] , flow $ unwords [ "If you see this warning and stack fails to download," , "but running the command again solves the problem," , "please report here: https://github.com/commercialhaskell/stack/issues/3510" , "Make sure to paste the output of 'stack --version'" ] ] return True retrySomeIO :: Monad m => IOException -> m Bool retrySomeIO e = return $ case ioe_type e of -- hGetBuf: resource vanished (Connection reset by peer) ResourceVanished -> True -- conservatively exclude all others _ -> False -- | Copied and extended version of Network.HTTP.Download.download. -- -- Has the following additional features: -- * Verifies that response content-length header (if present) -- matches expected length -- * Limits the download to (close to) the expected # of bytes -- * Verifies that the expected # bytes were downloaded (not too few) -- * Verifies md5 if response includes content-md5 header -- * Verifies the expected hashes -- -- Throws VerifiedDownloadException. -- Throws IOExceptions related to file system operations. -- Throws HttpException. verifiedDownload :: HasRunner env => DownloadRequest -> Path Abs File -- ^ destination -> (Maybe Integer -> ConduitM ByteString Void (RIO env) ()) -- ^ custom hook to observe progress -> RIO env Bool -- ^ Whether a download was performed verifiedDownload DownloadRequest{..} destpath progressSink = do let req = drRequest whenM' (liftIO getShouldDownload) $ do logDebug $ "Downloading " <> Stack.Prelude.display (decodeUtf8With lenientDecode (path req)) liftIO $ createDirectoryIfMissing True dir recoveringHttp drRetryPolicy $ withSinkFile fptmp $ httpSink req . go liftIO $ renameFile fptmp fp where whenM' mp m = do p <- mp if p then m >> return True else return False fp = toFilePath destpath fptmp = fp FP.<.> "tmp" dir = toFilePath $ parent destpath getShouldDownload = do fileExists <- doesFileExist fp if fileExists -- only download if file does not match expectations then not <$> fileMatchesExpectations -- or if it doesn't exist yet else return True -- precondition: file exists -- TODO: add logging fileMatchesExpectations = ((checkExpectations >> return True) `catch` \(_ :: VerifyFileException) -> return False) `catch` \(_ :: VerifiedDownloadException) -> return False checkExpectations = withBinaryFile fp ReadMode $ \h -> do for_ drLengthCheck $ checkFileSizeExpectations h runConduit $ sourceHandle h .| getZipSink (hashChecksToZipSink drRequest drHashChecks) -- doesn't move the handle checkFileSizeExpectations h expectedFileSize = do fileSizeInteger <- hFileSize h when (fileSizeInteger > toInteger (maxBound :: Int)) $ throwM $ WrongFileSize expectedFileSize fileSizeInteger let fileSize = fromInteger fileSizeInteger when (fileSize /= expectedFileSize) $ throwM $ WrongFileSize expectedFileSize fileSizeInteger checkContentLengthHeader headers expectedContentLength = case List.lookup hContentLength headers of Just lengthBS -> do let lengthStr = displayByteString lengthBS when (lengthStr /= show expectedContentLength) $ throwM $ WrongContentLength drRequest expectedContentLength lengthBS _ -> return () go sink res = do let headers = getResponseHeaders res mcontentLength = do hLength <- List.lookup hContentLength headers (i,_) <- readInteger hLength return i for_ drLengthCheck $ checkContentLengthHeader headers let hashChecks = (case List.lookup hContentMD5 headers of Just md5BS -> [ HashCheck { hashCheckAlgorithm = MD5 , hashCheckHexDigest = CheckHexDigestHeader md5BS } ] Nothing -> [] ) ++ drHashChecks maybe id (\len -> (CB.isolate len .|)) drLengthCheck $ getZipSink ( hashChecksToZipSink drRequest hashChecks *> maybe (pure ()) (assertLengthSink drRequest) drLengthCheck *> ZipSink sink *> ZipSink (progressSink mcontentLength)) stack-1.9.3.1/src/Network/HTTP/StackClient.hs0000644000000000000000000000753013455617610016732 0ustar0000000000000000{-# LANGUAGE OverloadedStrings #-} -- | -- Wrapper functions of 'Network.HTTP.Simple' and 'Network.HTTP.Client' to -- add the 'User-Agent' HTTP request header to each request. module Network.HTTP.StackClient ( httpJSON , httpLbs , httpLBS , httpNoBody , httpSink , setUserAgent , withResponse , withResponseByManager , setRequestMethod , setRequestHeader , addRequestHeader , setRequestBody , setRequestManager , getResponseHeaders , getResponseBody , getResponseStatusCode , Network.HTTP.Client.responseHeaders , Network.HTTP.Client.responseStatus , Network.HTTP.Client.responseBody , parseRequest , parseRequest_ , defaultRequest , setUri , getUri , path , checkResponse , parseUrlThrow , requestHeaders , getGlobalManager , applyDigestAuth , displayDigestAuthException , Request , RequestBody(RequestBodyBS, RequestBodyLBS) , Response , Manager , Header , HeaderName , HttpException(HttpExceptionRequest) , HttpExceptionContent(StatusCodeException) , hAccept , hContentLength , hContentMD5 , hCacheControl , hRange , methodPut , ok200 , partialContent206 , Proxy , useProxy , noProxy , proxyEnvironment , managerSetProxy , formDataBody , partFileRequestBody , partBS , partLBS ) where import Data.Aeson (FromJSON) import qualified Data.ByteString as Strict import Data.ByteString.Lazy (ByteString) import Data.Conduit (ConduitM, transPipe) import Data.Void (Void) import qualified Network.HTTP.Client import Network.HTTP.Client (BodyReader, Manager, Request, RequestBody(..), Response, Manager, HttpExceptionContent(..), parseRequest, parseRequest_, defaultRequest, getUri, path, checkResponse, parseUrlThrow, responseStatus, responseBody, useProxy, noProxy, proxyEnvironment, managerSetProxy, Proxy) import Network.HTTP.Client.Internal (setUri) import Network.HTTP.Simple (setRequestMethod, setRequestBody, setRequestHeader, addRequestHeader, setRequestManager, HttpException(..), getResponseBody, getResponseStatusCode, getResponseHeaders) import Network.HTTP.Types (hAccept, hContentLength, hContentMD5, hCacheControl, hRange, methodPut, Header, HeaderName, ok200, partialContent206) import Network.HTTP.Conduit (requestHeaders) import Network.HTTP.Client.TLS (getGlobalManager, applyDigestAuth, displayDigestAuthException) import qualified Network.HTTP.Simple import Network.HTTP.Client.MultipartFormData (formDataBody, partFileRequestBody, partBS, partLBS) import UnliftIO (MonadIO, MonadUnliftIO, withRunInIO, withUnliftIO, unliftIO) setUserAgent :: Request -> Request setUserAgent = setRequestHeader "User-Agent" ["The Haskell Stack"] httpJSON :: (MonadIO m, FromJSON a) => Request -> m (Response a) httpJSON = Network.HTTP.Simple.httpJSON . setUserAgent httpLbs :: MonadIO m => Request -> m (Response ByteString) httpLbs = Network.HTTP.Simple.httpLbs . setUserAgent httpLBS :: MonadIO m => Request -> m (Response ByteString) httpLBS = httpLbs httpNoBody :: MonadIO m => Request -> m (Response ()) httpNoBody = Network.HTTP.Simple.httpNoBody . setUserAgent httpSink :: MonadUnliftIO m => Request -> (Response () -> ConduitM Strict.ByteString Void m a) -> m a httpSink req inner = withUnliftIO $ \u -> Network.HTTP.Simple.httpSink (setUserAgent req) (transPipe (unliftIO u) . inner) withResponse :: (MonadUnliftIO m, MonadIO n) => Request -> (Response (ConduitM i Strict.ByteString n ()) -> m a) -> m a withResponse req inner = withRunInIO $ \run -> Network.HTTP.Simple.withResponse (setUserAgent req) (run . inner) withResponseByManager :: MonadUnliftIO m => Request -> Manager -> (Response BodyReader -> m a) -> m a withResponseByManager req man inner = withRunInIO $ \run -> Network.HTTP.Client.withResponse (setUserAgent req) man (run . inner) stack-1.9.3.1/src/Options/Applicative/Args.hs0000644000000000000000000000253413312026775017103 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude #-} {-# LANGUAGE OverloadedStrings #-} -- | Accepting arguments to be passed through to a sub-process. module Options.Applicative.Args (argsArgument ,argsOption ,cmdOption) where import Data.Attoparsec.Args import qualified Options.Applicative as O import Stack.Prelude -- | An argument which accepts a list of arguments e.g. @--ghc-options="-X P.hs \"this\""@. argsArgument :: O.Mod O.ArgumentFields [String] -> O.Parser [String] argsArgument = O.argument (do string <- O.str either O.readerError return (parseArgsFromString Escaping string)) -- | An option which accepts a list of arguments e.g. @--ghc-options="-X P.hs \"this\""@. argsOption :: O.Mod O.OptionFields [String] -> O.Parser [String] argsOption = O.option (do string <- O.str either O.readerError return (parseArgsFromString Escaping string)) -- | An option which accepts a command and a list of arguments e.g. @--exec "echo hello world"@ cmdOption :: O.Mod O.OptionFields (String, [String]) -> O.Parser (String, [String]) cmdOption = O.option (do string <- O.str xs <- either O.readerError return (parseArgsFromString Escaping string) case xs of [] -> O.readerError "Must provide a command" x:xs' -> return (x, xs')) stack-1.9.3.1/src/Options/Applicative/Builder/Extra.hs0000644000000000000000000002503013455617610020656 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude #-} {-# LANGUAGE RecordWildCards #-} {-# LANGUAGE ScopedTypeVariables #-} -- | Extra functions for optparse-applicative. module Options.Applicative.Builder.Extra (boolFlags ,boolFlagsNoDefault ,maybeBoolFlags ,firstBoolFlags ,enableDisableFlags ,enableDisableFlagsNoDefault ,extraHelpOption ,execExtraHelp ,textOption ,textArgument ,optionalFirst ,absFileOption ,relFileOption ,absDirOption ,relDirOption ,eitherReader' ,fileCompleter ,fileExtCompleter ,dirCompleter ,PathCompleterOpts(..) ,defaultPathCompleterOpts ,pathCompleterWith ,unescapeBashArg ) where import Data.List (isPrefixOf) import Data.Maybe import Data.Monoid hiding ((<>)) import qualified Data.Text as T import Options.Applicative import Options.Applicative.Types (readerAsk) import Path hiding (()) import Stack.Prelude import System.Directory (getCurrentDirectory, getDirectoryContents, doesDirectoryExist) import System.Environment (withArgs) import System.FilePath (takeBaseName, (), splitFileName, isRelative, takeExtension) -- | Enable/disable flags for a 'Bool'. boolFlags :: Bool -- ^ Default value -> String -- ^ Flag name -> String -- ^ Help suffix -> Mod FlagFields Bool -> Parser Bool boolFlags defaultValue = enableDisableFlags defaultValue True False -- | Enable/disable flags for a 'Bool', without a default case (to allow chaining with '<|>'). boolFlagsNoDefault :: String -- ^ Flag name -> String -- ^ Help suffix -> Mod FlagFields Bool -> Parser Bool boolFlagsNoDefault = enableDisableFlagsNoDefault True False -- | Enable/disable flags for a @('Maybe' 'Bool')@. maybeBoolFlags :: String -- ^ Flag name -> String -- ^ Help suffix -> Mod FlagFields (Maybe Bool) -> Parser (Maybe Bool) maybeBoolFlags = enableDisableFlags Nothing (Just True) (Just False) -- | Like 'maybeBoolFlags', but parsing a 'First'. firstBoolFlags :: String -> String -> Mod FlagFields (Maybe Bool) -> Parser (First Bool) firstBoolFlags long0 help0 mod0 = First <$> maybeBoolFlags long0 help0 mod0 -- | Enable/disable flags for any type. enableDisableFlags :: a -- ^ Default value -> a -- ^ Enabled value -> a -- ^ Disabled value -> String -- ^ Name -> String -- ^ Help suffix -> Mod FlagFields a -> Parser a enableDisableFlags defaultValue enabledValue disabledValue name helpSuffix mods = enableDisableFlagsNoDefault enabledValue disabledValue name helpSuffix mods <|> pure defaultValue -- | Enable/disable flags for any type, without a default (to allow chaining with '<|>') enableDisableFlagsNoDefault :: a -- ^ Enabled value -> a -- ^ Disabled value -> String -- ^ Name -> String -- ^ Help suffix -> Mod FlagFields a -> Parser a enableDisableFlagsNoDefault enabledValue disabledValue name helpSuffix mods = last <$> some ((flag' enabledValue (hidden <> internal <> long name <> help helpSuffix <> mods) <|> flag' disabledValue (hidden <> internal <> long ("no-" ++ name) <> help helpSuffix <> mods)) <|> flag' disabledValue (long ("[no-]" ++ name) <> help ("Enable/disable " ++ helpSuffix) <> mods)) where last xs = case reverse xs of [] -> impureThrow $ stringException "enableDisableFlagsNoDefault.last" x:_ -> x -- | Show an extra help option (e.g. @--docker-help@ shows help for all @--docker*@ args). -- -- To actually have that help appear, use 'execExtraHelp' before executing the main parser. extraHelpOption :: Bool -- ^ Hide from the brief description? -> String -- ^ Program name, e.g. @"stack"@ -> String -- ^ Option glob expression, e.g. @"docker*"@ -> String -- ^ Help option name, e.g. @"docker-help"@ -> Parser (a -> a) extraHelpOption hide progName fakeName helpName = infoOption (optDesc' ++ ".") (long helpName <> hidden <> internal) <*> infoOption (optDesc' ++ ".") (long fakeName <> help optDesc' <> (if hide then hidden <> internal else idm)) where optDesc' = concat ["Run '", takeBaseName progName, " --", helpName, "' for details"] -- | Display extra help if extra help option passed in arguments. -- -- Since optparse-applicative doesn't allow an arbitrary IO action for an 'abortOption', this -- was the best way I found that doesn't require manually formatting the help. execExtraHelp :: [String] -- ^ Command line arguments -> String -- ^ Extra help option name, e.g. @"docker-help"@ -> Parser a -- ^ Option parser for the relevant command -> String -- ^ Option description -> IO () execExtraHelp args helpOpt parser pd = when (args == ["--" ++ helpOpt]) $ withArgs ["--help"] $ do _ <- execParser (info (hiddenHelper <*> ((,) <$> parser <*> some (strArgument (metavar "OTHER ARGUMENTS") :: Parser String))) (fullDesc <> progDesc pd)) return () where hiddenHelper = abortOption ShowHelpText (long "help" <> hidden <> internal) -- | 'option', specialized to 'Text'. textOption :: Mod OptionFields Text -> Parser Text textOption = option (T.pack <$> readerAsk) -- | 'argument', specialized to 'Text'. textArgument :: Mod ArgumentFields Text -> Parser Text textArgument = argument (T.pack <$> readerAsk) -- | Like 'optional', but returning a 'First'. optionalFirst :: Alternative f => f a -> f (First a) optionalFirst = fmap First . optional absFileOption :: Mod OptionFields (Path Abs File) -> Parser (Path Abs File) absFileOption mods = option (eitherReader' parseAbsFile) $ completer (pathCompleterWith defaultPathCompleterOpts { pcoRelative = False }) <> mods relFileOption :: Mod OptionFields (Path Rel File) -> Parser (Path Rel File) relFileOption mods = option (eitherReader' parseRelFile) $ completer (pathCompleterWith defaultPathCompleterOpts { pcoAbsolute = False }) <> mods absDirOption :: Mod OptionFields (Path Abs Dir) -> Parser (Path Abs Dir) absDirOption mods = option (eitherReader' parseAbsDir) $ completer (pathCompleterWith defaultPathCompleterOpts { pcoRelative = False, pcoFileFilter = const False }) <> mods relDirOption :: Mod OptionFields (Path Rel Dir) -> Parser (Path Rel Dir) relDirOption mods = option (eitherReader' parseRelDir) $ completer (pathCompleterWith defaultPathCompleterOpts { pcoAbsolute = False, pcoFileFilter = const False }) <> mods -- | Like 'eitherReader', but accepting any @'Show' e@ on the 'Left'. eitherReader' :: Show e => (String -> Either e a) -> ReadM a eitherReader' f = eitherReader (mapLeft show . f) data PathCompleterOpts = PathCompleterOpts { pcoAbsolute :: Bool , pcoRelative :: Bool , pcoRootDir :: Maybe FilePath , pcoFileFilter :: FilePath -> Bool , pcoDirFilter :: FilePath -> Bool } defaultPathCompleterOpts :: PathCompleterOpts defaultPathCompleterOpts = PathCompleterOpts { pcoAbsolute = True , pcoRelative = True , pcoRootDir = Nothing , pcoFileFilter = const True , pcoDirFilter = const True } fileCompleter :: Completer fileCompleter = pathCompleterWith defaultPathCompleterOpts fileExtCompleter :: [String] -> Completer fileExtCompleter exts = pathCompleterWith defaultPathCompleterOpts { pcoFileFilter = (`elem` exts) . takeExtension } dirCompleter :: Completer dirCompleter = pathCompleterWith defaultPathCompleterOpts { pcoFileFilter = const False } pathCompleterWith :: PathCompleterOpts -> Completer pathCompleterWith PathCompleterOpts {..} = mkCompleter $ \inputRaw -> do -- Unescape input, to handle single and double quotes. Note that the -- results do not need to be re-escaped, due to some fiddly bash -- magic. let input = unescapeBashArg inputRaw let (inputSearchDir0, searchPrefix) = splitFileName input inputSearchDir = if inputSearchDir0 == "./" then "" else inputSearchDir0 msearchDir <- case (isRelative inputSearchDir, pcoAbsolute, pcoRelative) of (True, _, True) -> do rootDir <- maybe getCurrentDirectory return pcoRootDir return $ Just (rootDir inputSearchDir) (False, True, _) -> return $ Just inputSearchDir _ -> return Nothing case msearchDir of Nothing | input == "" && pcoAbsolute -> return ["/"] | otherwise -> return [] Just searchDir -> do entries <- getDirectoryContents searchDir `catch` \(_ :: IOException) -> return [] fmap catMaybes $ forM entries $ \entry -> -- Skip . and .. unless user is typing . or .. if entry `elem` ["..", "."] && searchPrefix `notElem` ["..", "."] then return Nothing else if searchPrefix `isPrefixOf` entry then do let path = searchDir entry case (pcoFileFilter path, pcoDirFilter path) of (True, True) -> return $ Just (inputSearchDir entry) (fileAllowed, dirAllowed) -> do isDir <- doesDirectoryExist path if (if isDir then dirAllowed else fileAllowed) then return $ Just (inputSearchDir entry) else return Nothing else return Nothing unescapeBashArg :: String -> String unescapeBashArg ('\'' : rest) = rest unescapeBashArg ('\"' : rest) = go rest where pattern = "$`\"\\\n" :: String go [] = [] go ('\\' : x : xs) | x `elem` pattern = x : xs | otherwise = '\\' : x : go xs go (x : xs) = x : go xs unescapeBashArg input = go input where go [] = [] go ('\\' : x : xs) = x : go xs go (x : xs) = x : go xs stack-1.9.3.1/src/Options/Applicative/Complicated.hs0000644000000000000000000001340513455617610020434 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude #-} -- | Simple interface to complicated program arguments. -- -- This is a "fork" of the @optparse-simple@ package that has some workarounds for -- optparse-applicative issues that become problematic with programs that have many options and -- subcommands. Because it makes the interface more complex, these workarounds are not suitable for -- pushing upstream to optparse-applicative. module Options.Applicative.Complicated ( addCommand , addSubCommands , complicatedOptions , complicatedParser ) where import Control.Monad.Trans.Except import Control.Monad.Trans.Writer import Data.Version import Options.Applicative import Options.Applicative.Types import Options.Applicative.Builder.Internal import Stack.Prelude import System.Environment -- | Generate and execute a complicated options parser. complicatedOptions :: Monoid a => Version -- ^ numeric version -> Maybe String -- ^ version string -> String -- ^ hpack numeric version, as string -> String -- ^ header -> String -- ^ program description (displayed between usage and options listing in the help output) -> String -- ^ footer -> Parser a -- ^ common settings -> Maybe (ParserFailure ParserHelp -> [String] -> IO (a,(b,a))) -- ^ optional handler for parser failure; 'handleParseResult' is called by -- default -> ExceptT b (Writer (Mod CommandFields (b,a))) () -- ^ commands (use 'addCommand') -> IO (a,b) complicatedOptions numericVersion versionString numericHpackVersion h pd footerStr commonParser mOnFailure commandParser = do args <- getArgs (a,(b,c)) <- case execParserPure (prefs noBacktrack) parser args of Failure _ | null args -> withArgs ["--help"] (execParser parser) -- call onFailure handler if it's present and parsing options failed Failure f | Just onFailure <- mOnFailure -> onFailure f args parseResult -> handleParseResult parseResult return (mappend c a,b) where parser = info (helpOption <*> versionOptions <*> complicatedParser "COMMAND|FILE" commonParser commandParser) desc desc = fullDesc <> header h <> progDesc pd <> footer footerStr versionOptions = case versionString of Nothing -> versionOption (showVersion numericVersion) Just s -> versionOption s <*> numericVersionOption <*> numericHpackVersionOption versionOption s = infoOption s (long "version" <> help "Show version") numericVersionOption = infoOption (showVersion numericVersion) (long "numeric-version" <> help "Show only version number") numericHpackVersionOption = infoOption numericHpackVersion (long "hpack-numeric-version" <> help "Show only hpack's version number") -- | Add a command to the options dispatcher. addCommand :: String -- ^ command string -> String -- ^ title of command -> String -- ^ footer of command help -> (a -> b) -- ^ constructor to wrap up command in common data type -> Parser c -- ^ common parser -> Parser a -- ^ command parser -> ExceptT b (Writer (Mod CommandFields (b,c))) () addCommand cmd title footerStr constr = addCommand' cmd title footerStr (\a c -> (constr a,c)) -- | Add a command that takes sub-commands to the options dispatcher. addSubCommands :: Monoid c => String -- ^ command string -> String -- ^ title of command -> String -- ^ footer of command help -> Parser c -- ^ common parser -> ExceptT b (Writer (Mod CommandFields (b,c))) () -- ^ sub-commands (use 'addCommand') -> ExceptT b (Writer (Mod CommandFields (b,c))) () addSubCommands cmd title footerStr commonParser commandParser = addCommand' cmd title footerStr (\(c1,(a,c2)) c3 -> (a,mconcat [c3, c2, c1])) commonParser (complicatedParser "COMMAND" commonParser commandParser) -- | Add a command to the options dispatcher. addCommand' :: String -- ^ command string -> String -- ^ title of command -> String -- ^ footer of command help -> (a -> c -> (b,c)) -- ^ constructor to wrap up command in common data type -> Parser c -- ^ common parser -> Parser a -- ^ command parser -> ExceptT b (Writer (Mod CommandFields (b,c))) () addCommand' cmd title footerStr constr commonParser inner = lift (tell (command cmd (info (constr <$> inner <*> commonParser) (progDesc title <> footer footerStr)))) -- | Generate a complicated options parser. complicatedParser :: Monoid a => String -- ^ metavar for the sub-command -> Parser a -- ^ common settings -> ExceptT b (Writer (Mod CommandFields (b,a))) () -- ^ commands (use 'addCommand') -> Parser (a,(b,a)) complicatedParser commandMetavar commonParser commandParser = (,) <$> commonParser <*> case runWriter (runExceptT commandParser) of (Right (),d) -> hsubparser' commandMetavar d (Left b,_) -> pure (b,mempty) -- | Subparser with @--help@ argument. Borrowed with slight modification -- from Options.Applicative.Extra. hsubparser' :: String -> Mod CommandFields a -> Parser a hsubparser' commandMetavar m = mkParser d g rdr where Mod _ d g = metavar commandMetavar `mappend` m (groupName, cmds, subs) = mkCommand m rdr = CmdReader groupName cmds (fmap add_helper . subs) add_helper pinfo = pinfo { infoParser = infoParser pinfo <**> helpOption } -- | Non-hidden help option. helpOption :: Parser (a -> a) helpOption = abortOption ShowHelpText $ long "help" <> help "Show this help text" stack-1.9.3.1/src/Path/CheckInstall.hs0000644000000000000000000000470413455617610015556 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude #-} {-# LANGUAGE FlexibleContexts #-} {-# LANGUAGE OverloadedStrings #-} module Path.CheckInstall where import Control.Monad.Extra (anyM, (&&^)) import qualified Data.Text as T import Stack.Prelude import Stack.PrettyPrint import Stack.Types.Config import qualified System.Directory as D import qualified System.FilePath as FP -- | Checks if the installed executable will be available on the user's -- PATH. This doesn't use @envSearchPath menv@ because it includes paths -- only visible when running in the stack environment. warnInstallSearchPathIssues :: HasConfig env => FilePath -> [Text] -> RIO env () warnInstallSearchPathIssues destDir installed = do searchPath <- liftIO FP.getSearchPath destDirIsInPATH <- liftIO $ anyM (\dir -> D.doesDirectoryExist dir &&^ fmap (FP.equalFilePath destDir) (D.canonicalizePath dir)) searchPath if destDirIsInPATH then forM_ installed $ \exe -> do mexePath <- (liftIO . D.findExecutable . T.unpack) exe case mexePath of Just exePath -> do exeDir <- (liftIO . fmap FP.takeDirectory . D.canonicalizePath) exePath unless (exeDir `FP.equalFilePath` destDir) $ do prettyWarnL [ flow "The" , styleFile . fromString . T.unpack $ exe , flow "executable found on the PATH environment variable is" , styleFile . fromString $ exePath , flow "and not the version that was just installed." , flow "This means that" , styleFile . fromString . T.unpack $ exe , "calls on the command line will not use this version." ] Nothing -> do prettyWarnL [ flow "Installation path" , styleDir . fromString $ destDir , flow "is on the PATH but the" , styleFile . fromString . T.unpack $ exe , flow "executable that was just installed could not be found on the PATH." ] else do prettyWarnL [ flow "Installation path " , styleDir . fromString $ destDir , "not found on the PATH environment variable." ] stack-1.9.3.1/src/Path/Extra.hs0000644000000000000000000001111613312026775014266 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude #-} {-# LANGUAGE ViewPatterns #-} -- | Extra Path utilities. module Path.Extra (toFilePathNoTrailingSep ,dropRoot ,parseCollapsedAbsDir ,parseCollapsedAbsFile ,concatAndColapseAbsDir ,rejectMissingFile ,rejectMissingDir ,pathToByteString ,pathToLazyByteString ,pathToText ,tryGetModificationTime ) where import Data.Bool (bool) import Data.Time (UTCTime) import Path import Path.IO import Path.Internal (Path(..)) import RIO import System.IO.Error (isDoesNotExistError) import qualified Data.ByteString.Char8 as BS import qualified Data.ByteString.Lazy.Char8 as BSL import qualified Data.Text as T import qualified Data.Text.Encoding as T import qualified System.FilePath as FP -- | Convert to FilePath but don't add a trailing slash. toFilePathNoTrailingSep :: Path loc Dir -> FilePath toFilePathNoTrailingSep = FP.dropTrailingPathSeparator . toFilePath -- | Collapse intermediate "." and ".." directories from path, then parse -- it with 'parseAbsDir'. -- (probably should be moved to the Path module) parseCollapsedAbsDir :: MonadThrow m => FilePath -> m (Path Abs Dir) parseCollapsedAbsDir = parseAbsDir . collapseFilePath -- | Collapse intermediate "." and ".." directories from path, then parse -- it with 'parseAbsFile'. -- (probably should be moved to the Path module) parseCollapsedAbsFile :: MonadThrow m => FilePath -> m (Path Abs File) parseCollapsedAbsFile = parseAbsFile . collapseFilePath -- | Add a relative FilePath to the end of a Path -- We can't parse the FilePath first because we need to account for ".." -- in the FilePath (#2895) concatAndColapseAbsDir :: MonadThrow m => Path Abs Dir -> FilePath -> m (Path Abs Dir) concatAndColapseAbsDir base rel = parseCollapsedAbsDir (toFilePath base FP. rel) -- | Collapse intermediate "." and ".." directories from a path. -- -- > collapseFilePath "./foo" == "foo" -- > collapseFilePath "/bar/../baz" == "/baz" -- > collapseFilePath "/../baz" == "/../baz" -- > collapseFilePath "parent/foo/baz/../bar" == "parent/foo/bar" -- > collapseFilePath "parent/foo/baz/../../bar" == "parent/bar" -- > collapseFilePath "parent/foo/.." == "parent" -- > collapseFilePath "/parent/foo/../../bar" == "/bar" -- -- (adapted from @Text.Pandoc.Shared@) collapseFilePath :: FilePath -> FilePath collapseFilePath = FP.joinPath . reverse . foldl' go [] . FP.splitDirectories where go rs "." = rs go r@(p:rs) ".." = case p of ".." -> "..":r (checkPathSeparator -> True) -> "..":r _ -> rs go _ (checkPathSeparator -> True) = [[FP.pathSeparator]] go rs x = x:rs checkPathSeparator [x] = FP.isPathSeparator x checkPathSeparator _ = False -- | Drop the root (either @\/@ on POSIX or @C:\\@, @D:\\@, etc. on -- Windows). dropRoot :: Path Abs t -> Path Rel t dropRoot (Path l) = Path (FP.dropDrive l) -- | If given file in 'Maybe' does not exist, ensure we have 'Nothing'. This -- is to be used in conjunction with 'forgivingAbsence' and -- 'resolveFile'. -- -- Previously the idiom @forgivingAbsence (relsoveFile …)@ alone was used, -- which relied on 'canonicalizePath' throwing 'isDoesNotExistError' when -- path does not exist. As it turns out, this behavior is actually not -- intentional and unreliable, see -- . This was “fixed” in -- version @1.2.3.0@ of @directory@ package (now it never throws). To make -- it work with all versions, we need to use the following idiom: -- -- > forgivingAbsence (resolveFile …) >>= rejectMissingFile rejectMissingFile :: MonadIO m => Maybe (Path Abs File) -> m (Maybe (Path Abs File)) rejectMissingFile Nothing = return Nothing rejectMissingFile (Just p) = bool Nothing (Just p) `liftM` doesFileExist p -- | See 'rejectMissingFile'. rejectMissingDir :: MonadIO m => Maybe (Path Abs Dir) -> m (Maybe (Path Abs Dir)) rejectMissingDir Nothing = return Nothing rejectMissingDir (Just p) = bool Nothing (Just p) `liftM` doesDirExist p -- | Convert to a lazy ByteString using toFilePath and UTF8. pathToLazyByteString :: Path b t -> BSL.ByteString pathToLazyByteString = BSL.fromStrict . pathToByteString -- | Convert to a ByteString using toFilePath and UTF8. pathToByteString :: Path b t -> BS.ByteString pathToByteString = T.encodeUtf8 . pathToText pathToText :: Path b t -> T.Text pathToText = T.pack . toFilePath tryGetModificationTime :: MonadIO m => Path Abs File -> m (Either () UTCTime) tryGetModificationTime = liftIO . tryJust (guard . isDoesNotExistError) . getModificationTime stack-1.9.3.1/src/Path/Find.hs0000644000000000000000000000742213455617610014072 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude #-} {-# LANGUAGE DataKinds #-} -- | Finding files. module Path.Find (findFileUp ,findDirUp ,findFiles ,findInParents) where import Stack.Prelude import System.IO.Error (isPermissionError) import Data.List import Path import Path.IO hiding (findFiles) import System.PosixCompat.Files (getSymbolicLinkStatus, isSymbolicLink) -- | Find the location of a file matching the given predicate. findFileUp :: (MonadIO m,MonadThrow m) => Path Abs Dir -- ^ Start here. -> (Path Abs File -> Bool) -- ^ Predicate to match the file. -> Maybe (Path Abs Dir) -- ^ Do not ascend above this directory. -> m (Maybe (Path Abs File)) -- ^ Absolute file path. findFileUp = findPathUp snd -- | Find the location of a directory matching the given predicate. findDirUp :: (MonadIO m,MonadThrow m) => Path Abs Dir -- ^ Start here. -> (Path Abs Dir -> Bool) -- ^ Predicate to match the directory. -> Maybe (Path Abs Dir) -- ^ Do not ascend above this directory. -> m (Maybe (Path Abs Dir)) -- ^ Absolute directory path. findDirUp = findPathUp fst -- | Find the location of a path matching the given predicate. findPathUp :: (MonadIO m,MonadThrow m) => (([Path Abs Dir],[Path Abs File]) -> [Path Abs t]) -- ^ Choose path type from pair. -> Path Abs Dir -- ^ Start here. -> (Path Abs t -> Bool) -- ^ Predicate to match the path. -> Maybe (Path Abs Dir) -- ^ Do not ascend above this directory. -> m (Maybe (Path Abs t)) -- ^ Absolute path. findPathUp pathType dir p upperBound = do entries <- listDir dir case find p (pathType entries) of Just path -> return (Just path) Nothing | Just dir == upperBound -> return Nothing | parent dir == dir -> return Nothing | otherwise -> findPathUp pathType (parent dir) p upperBound -- | Find files matching predicate below a root directory. -- -- NOTE: this skips symbolic directory links, to avoid loops. This may -- not make sense for all uses of file finding. -- -- TODO: write one of these that traverses symbolic links but -- efficiently ignores loops. findFiles :: Path Abs Dir -- ^ Root directory to begin with. -> (Path Abs File -> Bool) -- ^ Predicate to match files. -> (Path Abs Dir -> Bool) -- ^ Predicate for which directories to traverse. -> IO [Path Abs File] -- ^ List of matching files. findFiles dir p traversep = do (dirs,files) <- catchJust (\ e -> if isPermissionError e then Just () else Nothing) (listDir dir) (\ _ -> return ([], [])) filteredFiles <- evaluate $ force (filter p files) filteredDirs <- filterM (fmap not . isSymLink) dirs subResults <- forM filteredDirs (\entry -> if traversep entry then findFiles entry p traversep else return []) return (concat (filteredFiles : subResults)) isSymLink :: Path Abs t -> IO Bool isSymLink = fmap isSymbolicLink . getSymbolicLinkStatus . toFilePath -- | @findInParents f path@ applies @f@ to @path@ and its 'parent's until -- it finds a 'Just' or reaches the root directory. findInParents :: MonadIO m => (Path Abs Dir -> m (Maybe a)) -> Path Abs Dir -> m (Maybe a) findInParents f path = do mres <- f path case mres of Just res -> return (Just res) Nothing -> do let next = parent path if next == path then return Nothing else findInParents f next stack-1.9.3.1/src/Stack/Build.hs0000644000000000000000000004015213455617610014417 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude #-} {-# LANGUAGE CPP #-} {-# LANGUAGE ConstraintKinds #-} {-# LANGUAGE DeriveDataTypeable #-} {-# LANGUAGE DeriveGeneric #-} {-# LANGUAGE FlexibleContexts #-} {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE TemplateHaskell #-} {-# LANGUAGE TupleSections #-} {-# LANGUAGE ViewPatterns #-} -- | Build the project. module Stack.Build (build ,loadPackage ,mkBaseConfigOpts ,queryBuildInfo ,splitObjsWarning ,CabalVersionException(..)) where import Stack.Prelude import Data.Aeson (Value (Object, Array), (.=), object) import qualified Data.HashMap.Strict as HM import Data.List ((\\), isPrefixOf) import Data.List.Extra (groupSort) import Data.List.NonEmpty (NonEmpty(..)) import qualified Data.List.NonEmpty as NE import qualified Data.Map as Map import qualified Data.Set as Set import qualified Data.Text as T import Data.Text.Encoding (decodeUtf8) import qualified Data.Text.IO as TIO import Data.Text.Read (decimal) import qualified Data.Vector as V import qualified Data.Yaml as Yaml import Stack.Build.ConstructPlan import Stack.Build.Execute import Stack.Build.Haddock import Stack.Build.Installed import Stack.Build.Source import Stack.Build.Target import Stack.Package import Stack.PackageLocation (parseSingleCabalFileIndex) import Stack.Types.Build import Stack.Types.BuildPlan import Stack.Types.Config import Stack.Types.FlagName import Stack.Types.NamedComponent import Stack.Types.Package import Stack.Types.PackageIdentifier import Stack.Types.PackageName import Stack.Types.Version import Stack.Types.Compiler (compilerVersionText #ifdef WINDOWS ,getGhcVersion #endif ) import System.FileLock (FileLock, unlockFile) #ifdef WINDOWS import System.Win32.Console (setConsoleCP, setConsoleOutputCP, getConsoleCP, getConsoleOutputCP) #endif -- | Build. -- -- If a buildLock is passed there is an important contract here. That lock must -- protect the snapshot, and it must be safe to unlock it if there are no further -- modifications to the snapshot to be performed by this build. build :: HasEnvConfig env => (Set (Path Abs File) -> IO ()) -- ^ callback after discovering all local files -> Maybe FileLock -> BuildOptsCLI -> RIO env () build setLocalFiles mbuildLk boptsCli = fixCodePage $ do bopts <- view buildOptsL let profiling = boptsLibProfile bopts || boptsExeProfile bopts let symbols = not (boptsLibStrip bopts || boptsExeStrip bopts) (targets, ls, locals, extraToBuild, sourceMap) <- loadSourceMapFull NeedTargets boptsCli -- Set local files, necessary for file watching stackYaml <- view stackYamlL liftIO $ setLocalFiles $ Set.insert stackYaml $ Set.unions -- The `locals` value above only contains local project -- packages, not local dependencies. This will get _all_ -- of the local files we're interested in -- watching. Arguably, we should not bother watching repo -- and archive files, since those shouldn't -- change. That's a possible optimization to consider. [lpFiles lp | PSFiles lp _ <- Map.elems sourceMap] (installedMap, globalDumpPkgs, snapshotDumpPkgs, localDumpPkgs) <- getInstalled GetInstalledOpts { getInstalledProfiling = profiling , getInstalledHaddock = shouldHaddockDeps bopts , getInstalledSymbols = symbols } sourceMap baseConfigOpts <- mkBaseConfigOpts boptsCli plan <- constructPlan ls baseConfigOpts locals extraToBuild localDumpPkgs loadPackage sourceMap installedMap (boptsCLIInitialBuildSteps boptsCli) allowLocals <- view $ configL.to configAllowLocals unless allowLocals $ case justLocals plan of [] -> return () localsIdents -> throwM $ LocalPackagesPresent localsIdents -- If our work to do is all local, let someone else have a turn with the snapshot. -- They won't damage what's already in there. case (mbuildLk, allLocal plan) of -- NOTE: This policy is too conservative. In the future we should be able to -- schedule unlocking as an Action that happens after all non-local actions are -- complete. (Just lk,True) -> do logDebug "All installs are local; releasing snapshot lock early." liftIO $ unlockFile lk _ -> return () checkCabalVersion warnAboutSplitObjs bopts warnIfExecutablesWithSameNameCouldBeOverwritten locals plan when (boptsPreFetch bopts) $ preFetch plan if boptsCLIDryrun boptsCli then printPlan plan else executePlan boptsCli baseConfigOpts locals globalDumpPkgs snapshotDumpPkgs localDumpPkgs installedMap targets plan -- | If all the tasks are local, they don't mutate anything outside of our local directory. allLocal :: Plan -> Bool allLocal = all (== Local) . map taskLocation . Map.elems . planTasks justLocals :: Plan -> [PackageIdentifier] justLocals = map taskProvides . filter ((== Local) . taskLocation) . Map.elems . planTasks checkCabalVersion :: HasEnvConfig env => RIO env () checkCabalVersion = do allowNewer <- view $ configL.to configAllowNewer cabalVer <- view cabalVersionL -- https://github.com/haskell/cabal/issues/2023 when (allowNewer && cabalVer < $(mkVersion "1.22")) $ throwM $ CabalVersionException $ "Error: --allow-newer requires at least Cabal version 1.22, but version " ++ versionString cabalVer ++ " was found." newtype CabalVersionException = CabalVersionException { unCabalVersionException :: String } deriving (Typeable) instance Show CabalVersionException where show = unCabalVersionException instance Exception CabalVersionException -- | See https://github.com/commercialhaskell/stack/issues/1198. warnIfExecutablesWithSameNameCouldBeOverwritten :: HasLogFunc env => [LocalPackage] -> Plan -> RIO env () warnIfExecutablesWithSameNameCouldBeOverwritten locals plan = do logDebug "Checking if we are going to build multiple executables with the same name" forM_ (Map.toList warnings) $ \(exe,(toBuild,otherLocals)) -> do let exe_s | length toBuild > 1 = "several executables with the same name:" | otherwise = "executable" exesText pkgs = T.intercalate ", " ["'" <> packageNameText p <> ":" <> exe <> "'" | p <- pkgs] (logWarn . display . T.unlines . concat) [ [ "Building " <> exe_s <> " " <> exesText toBuild <> "." ] , [ "Only one of them will be available via 'stack exec' or locally installed." | length toBuild > 1 ] , [ "Other executables with the same name might be overwritten: " <> exesText otherLocals <> "." | not (null otherLocals) ] ] where -- Cases of several local packages having executables with the same name. -- The Map entries have the following form: -- -- executable name: ( package names for executables that are being built -- , package names for other local packages that have an -- executable with the same name -- ) warnings :: Map Text ([PackageName],[PackageName]) warnings = Map.mapMaybe (\(pkgsToBuild,localPkgs) -> case (pkgsToBuild,NE.toList localPkgs \\ NE.toList pkgsToBuild) of (_ :| [],[]) -> -- We want to build the executable of single local package -- and there are no other local packages with an executable of -- the same name. Nothing to warn about, ignore. Nothing (_,otherLocals) -> -- We could be here for two reasons (or their combination): -- 1) We are building two or more executables with the same -- name that will end up overwriting each other. -- 2) In addition to the executable(s) that we want to build -- there are other local packages with an executable of the -- same name that might get overwritten. -- Both cases warrant a warning. Just (NE.toList pkgsToBuild,otherLocals)) (Map.intersectionWith (,) exesToBuild localExes) exesToBuild :: Map Text (NonEmpty PackageName) exesToBuild = collect [ (exe,pkgName) | (pkgName,task) <- Map.toList (planTasks plan) , TTFiles lp _ <- [taskType task] -- FIXME analyze logic here, do we need to check for Local? , exe <- (Set.toList . exeComponents . lpComponents) lp ] localExes :: Map Text (NonEmpty PackageName) localExes = collect [ (exe,packageName pkg) | pkg <- map lpPackage locals , exe <- Set.toList (packageExes pkg) ] collect :: Ord k => [(k,v)] -> Map k (NonEmpty v) collect = Map.map NE.fromList . Map.fromDistinctAscList . groupSort warnAboutSplitObjs :: HasLogFunc env => BuildOpts -> RIO env () warnAboutSplitObjs bopts | boptsSplitObjs bopts = do logWarn $ "Building with --split-objs is enabled. " <> fromString splitObjsWarning warnAboutSplitObjs _ = return () splitObjsWarning :: String splitObjsWarning = unwords [ "Note that this feature is EXPERIMENTAL, and its behavior may be changed and improved." , "You will need to clean your workdirs before use. If you want to compile all dependencies" , "with split-objs, you will need to delete the snapshot (and all snapshots that could" , "reference that snapshot)." ] -- | Get the @BaseConfigOpts@ necessary for constructing configure options mkBaseConfigOpts :: (MonadIO m, MonadReader env m, HasEnvConfig env, MonadThrow m) => BuildOptsCLI -> m BaseConfigOpts mkBaseConfigOpts boptsCli = do bopts <- view buildOptsL snapDBPath <- packageDatabaseDeps localDBPath <- packageDatabaseLocal snapInstallRoot <- installationRootDeps localInstallRoot <- installationRootLocal packageExtraDBs <- packageDatabaseExtra return BaseConfigOpts { bcoSnapDB = snapDBPath , bcoLocalDB = localDBPath , bcoSnapInstallRoot = snapInstallRoot , bcoLocalInstallRoot = localInstallRoot , bcoBuildOpts = bopts , bcoBuildOptsCLI = boptsCli , bcoExtraDBs = packageExtraDBs } -- | Provide a function for loading package information from the package index loadPackage :: HasEnvConfig env => PackageLocationIndex FilePath -> Map FlagName Bool -> [Text] -> RIO env Package loadPackage loc flags ghcOptions = do compiler <- view actualCompilerVersionL platform <- view platformL root <- view projectRootL let pkgConfig = PackageConfig { packageConfigEnableTests = False , packageConfigEnableBenchmarks = False , packageConfigFlags = flags , packageConfigGhcOptions = ghcOptions , packageConfigCompilerVersion = compiler , packageConfigPlatform = platform } resolvePackage pkgConfig <$> parseSingleCabalFileIndex root loc -- | Set the code page for this process as necessary. Only applies to Windows. -- See: https://github.com/commercialhaskell/stack/issues/738 fixCodePage :: HasEnvConfig env => RIO env a -> RIO env a #ifdef WINDOWS fixCodePage inner = do mcp <- view $ configL.to configModifyCodePage ghcVersion <- view $ actualCompilerVersionL.to getGhcVersion if mcp && ghcVersion < $(mkVersion "7.10.3") then fixCodePage' -- GHC >=7.10.3 doesn't need this code page hack. else inner where fixCodePage' = do origCPI <- liftIO getConsoleCP origCPO <- liftIO getConsoleOutputCP let setInput = origCPI /= expected setOutput = origCPO /= expected fixInput | setInput = bracket_ (liftIO $ do setConsoleCP expected) (liftIO $ setConsoleCP origCPI) | otherwise = id fixOutput | setOutput = bracket_ (liftIO $ do setConsoleOutputCP expected) (liftIO $ setConsoleOutputCP origCPO) | otherwise = id case (setInput, setOutput) of (False, False) -> return () (True, True) -> warn "" (True, False) -> warn " input" (False, True) -> warn " output" fixInput $ fixOutput inner expected = 65001 -- UTF-8 warn typ = logInfo $ "Setting" <> typ <> " codepage to UTF-8 (65001) to ensure correct output from GHC" #else fixCodePage = id #endif -- | Query information about the build and print the result to stdout in YAML format. queryBuildInfo :: HasEnvConfig env => [Text] -- ^ selectors -> RIO env () queryBuildInfo selectors0 = rawBuildInfo >>= select id selectors0 >>= liftIO . TIO.putStrLn . addGlobalHintsComment . decodeUtf8 . Yaml.encode where select _ [] value = return value select front (sel:sels) value = case value of Object o -> case HM.lookup sel o of Nothing -> err "Selector not found" Just value' -> cont value' Array v -> case decimal sel of Right (i, "") | i >= 0 && i < V.length v -> cont $ v V.! i | otherwise -> err "Index out of range" _ -> err "Encountered array and needed numeric selector" _ -> err $ "Cannot apply selector to " ++ show value where cont = select (front . (sel:)) sels err msg = throwString $ msg ++ ": " ++ show (front [sel]) -- Include comments to indicate that this portion of the "stack -- query" API is not necessarily stable. addGlobalHintsComment | null selectors0 = T.replace globalHintsLine ("\n" <> globalHintsComment <> globalHintsLine) -- Append comment instead of pre-pending. The reasoning here is -- that something *could* expect that the result of 'stack query -- global-hints ghc-boot' is just a string literal. Seems easier -- for to expect the first line of the output to be the literal. | ["global-hints"] `isPrefixOf` selectors0 = (<> ("\n" <> globalHintsComment)) | otherwise = id globalHintsLine = "\nglobal-hints:\n" globalHintsComment = T.concat [ "# Note: global-hints is experimental and may be renamed / removed in the future.\n" , "# See https://github.com/commercialhaskell/stack/issues/3796" ] -- | Get the raw build information object rawBuildInfo :: HasEnvConfig env => RIO env Value rawBuildInfo = do (locals, _sourceMap) <- loadSourceMap NeedTargets defaultBuildOptsCLI wantedCompiler <- view $ wantedCompilerVersionL.to compilerVersionText actualCompiler <- view $ actualCompilerVersionL.to compilerVersionText globalHints <- view globalHintsL return $ object [ "locals" .= Object (HM.fromList $ map localToPair locals) , "compiler" .= object [ "wanted" .= wantedCompiler , "actual" .= actualCompiler ] , "global-hints" .= globalHints ] where localToPair lp = (T.pack $ packageNameString $ packageName p, value) where p = lpPackage lp value = object [ "version" .= packageVersion p , "path" .= toFilePath (lpDir lp) ] stack-1.9.3.1/src/Stack/Build/Cache.hs0000644000000000000000000003661713455617610015435 0ustar0000000000000000{-# LANGUAGE CPP #-} {-# LANGUAGE NoImplicitPrelude #-} {-# LANGUAGE DeriveGeneric #-} {-# LANGUAGE MultiParamTypeClasses #-} {-# LANGUAGE TemplateHaskell #-} {-# LANGUAGE TupleSections #-} {-# LANGUAGE ConstraintKinds #-} {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE DataKinds #-} {-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE FlexibleContexts #-} {-# OPTIONS_GHC -fno-warn-orphans #-} -- | Cache information about previous builds module Stack.Build.Cache ( tryGetBuildCache , tryGetConfigCache , tryGetCabalMod , getInstalledExes , tryGetFlagCache , deleteCaches , markExeInstalled , markExeNotInstalled , writeFlagCache , writeBuildCache , writeConfigCache , writeCabalMod , setTestSuccess , unsetTestSuccess , checkTestSuccess , writePrecompiledCache , readPrecompiledCache -- Exported for testing , BuildCache(..) ) where import Stack.Prelude import Crypto.Hash (hashWith, SHA256(..)) import Control.Monad.Trans.Maybe import qualified Data.ByteArray as Mem (convert) import qualified Data.ByteString.Base64.URL as B64URL import qualified Data.ByteString as B import qualified Data.ByteString.Char8 as S8 #ifdef mingw32_HOST_OS import Data.Char (ord) #endif import qualified Data.Map as M import qualified Data.Set as Set import qualified Data.Store as Store import Data.Store.VersionTagged import qualified Data.Text as T import qualified Data.Text.Encoding as TE import Path import Path.IO import Stack.Constants.Config import Stack.Types.Build import Stack.Types.BuildPlan import Stack.Types.Compiler import Stack.Types.Config import Stack.Types.GhcPkgId import Stack.Types.NamedComponent import Stack.Types.Package import Stack.Types.PackageIdentifier import Stack.Types.Version import qualified System.FilePath as FP -- | Directory containing files to mark an executable as installed exeInstalledDir :: (MonadReader env m, HasEnvConfig env, MonadThrow m) => InstallLocation -> m (Path Abs Dir) exeInstalledDir Snap = ( $(mkRelDir "installed-packages")) `liftM` installationRootDeps exeInstalledDir Local = ( $(mkRelDir "installed-packages")) `liftM` installationRootLocal -- | Get all of the installed executables getInstalledExes :: (MonadReader env m, HasEnvConfig env, MonadIO m, MonadThrow m) => InstallLocation -> m [PackageIdentifier] getInstalledExes loc = do dir <- exeInstalledDir loc (_, files) <- liftIO $ handleIO (const $ return ([], [])) $ listDir dir return $ concat $ M.elems $ -- If there are multiple install records (from a stack version -- before https://github.com/commercialhaskell/stack/issues/2373 -- was fixed), then we don't know which is correct - ignore them. M.fromListWith (\_ _ -> []) $ map (\x -> (packageIdentifierName x, [x])) $ mapMaybe (parsePackageIdentifierFromString . toFilePath . filename) files -- | Mark the given executable as installed markExeInstalled :: (MonadReader env m, HasEnvConfig env, MonadIO m, MonadThrow m) => InstallLocation -> PackageIdentifier -> m () markExeInstalled loc ident = do dir <- exeInstalledDir loc ensureDir dir ident' <- parseRelFile $ packageIdentifierString ident let fp = toFilePath $ dir ident' -- Remove old install records for this package. -- TODO: This is a bit in-efficient. Put all this metadata into one file? installed <- getInstalledExes loc forM_ (filter (\x -> packageIdentifierName ident == packageIdentifierName x) installed) (markExeNotInstalled loc) -- TODO consideration for the future: list all of the executables -- installed, and invalidate this file in getInstalledExes if they no -- longer exist liftIO $ B.writeFile fp "Installed" -- | Mark the given executable as not installed markExeNotInstalled :: (MonadReader env m, HasEnvConfig env, MonadIO m, MonadThrow m) => InstallLocation -> PackageIdentifier -> m () markExeNotInstalled loc ident = do dir <- exeInstalledDir loc ident' <- parseRelFile $ packageIdentifierString ident liftIO $ ignoringAbsence (removeFile $ dir ident') buildCacheFile :: (HasEnvConfig env, MonadReader env m, MonadThrow m) => Path Abs Dir -> NamedComponent -> m (Path Abs File) buildCacheFile dir component = do cachesDir <- buildCachesDir dir let nonLibComponent prefix name = prefix <> "-" <> T.unpack name cacheFileName <- parseRelFile $ case component of CLib -> "lib" CInternalLib name -> nonLibComponent "internal-lib" name CExe name -> nonLibComponent "exe" name CTest name -> nonLibComponent "test" name CBench name -> nonLibComponent "bench" name return $ cachesDir cacheFileName -- | Try to read the dirtiness cache for the given package directory. tryGetBuildCache :: HasEnvConfig env => Path Abs Dir -> NamedComponent -> RIO env (Maybe (Map FilePath FileCacheInfo)) tryGetBuildCache dir component = liftM (fmap buildCacheTimes) . $(versionedDecodeFile buildCacheVC) =<< buildCacheFile dir component -- | Try to read the dirtiness cache for the given package directory. tryGetConfigCache :: HasEnvConfig env => Path Abs Dir -> RIO env (Maybe ConfigCache) tryGetConfigCache dir = $(versionedDecodeFile configCacheVC) =<< configCacheFile dir -- | Try to read the mod time of the cabal file from the last build tryGetCabalMod :: HasEnvConfig env => Path Abs Dir -> RIO env (Maybe ModTime) tryGetCabalMod dir = $(versionedDecodeFile modTimeVC) =<< configCabalMod dir -- | Write the dirtiness cache for this package's files. writeBuildCache :: HasEnvConfig env => Path Abs Dir -> NamedComponent -> Map FilePath FileCacheInfo -> RIO env () writeBuildCache dir component times = do fp <- buildCacheFile dir component $(versionedEncodeFile buildCacheVC) fp BuildCache { buildCacheTimes = times } -- | Write the dirtiness cache for this package's configuration. writeConfigCache :: HasEnvConfig env => Path Abs Dir -> ConfigCache -> RIO env () writeConfigCache dir x = do fp <- configCacheFile dir $(versionedEncodeFile configCacheVC) fp x -- | See 'tryGetCabalMod' writeCabalMod :: HasEnvConfig env => Path Abs Dir -> ModTime -> RIO env () writeCabalMod dir x = do fp <- configCabalMod dir $(versionedEncodeFile modTimeVC) fp x -- | Delete the caches for the project. deleteCaches :: (MonadIO m, MonadReader env m, HasEnvConfig env, MonadThrow m) => Path Abs Dir -> m () deleteCaches dir = do {- FIXME confirm that this is acceptable to remove bfp <- buildCacheFile dir removeFileIfExists bfp -} cfp <- configCacheFile dir liftIO $ ignoringAbsence (removeFile cfp) flagCacheFile :: (MonadIO m, MonadThrow m, MonadReader env m, HasEnvConfig env) => Installed -> m (Path Abs File) flagCacheFile installed = do rel <- parseRelFile $ case installed of Library _ gid _ -> ghcPkgIdString gid Executable ident -> packageIdentifierString ident dir <- flagCacheLocal return $ dir rel -- | Loads the flag cache for the given installed extra-deps tryGetFlagCache :: HasEnvConfig env => Installed -> RIO env (Maybe ConfigCache) tryGetFlagCache gid = do fp <- flagCacheFile gid $(versionedDecodeFile configCacheVC) fp writeFlagCache :: HasEnvConfig env => Installed -> ConfigCache -> RIO env () writeFlagCache gid cache = do file <- flagCacheFile gid ensureDir (parent file) $(versionedEncodeFile configCacheVC) file cache -- | Mark a test suite as having succeeded setTestSuccess :: HasEnvConfig env => Path Abs Dir -> RIO env () setTestSuccess dir = do fp <- testSuccessFile dir $(versionedEncodeFile testSuccessVC) fp True -- | Mark a test suite as not having succeeded unsetTestSuccess :: HasEnvConfig env => Path Abs Dir -> RIO env () unsetTestSuccess dir = do fp <- testSuccessFile dir $(versionedEncodeFile testSuccessVC) fp False -- | Check if the test suite already passed checkTestSuccess :: HasEnvConfig env => Path Abs Dir -> RIO env Bool checkTestSuccess dir = liftM (fromMaybe False) ($(versionedDecodeFile testSuccessVC) =<< testSuccessFile dir) -------------------------------------- -- Precompiled Cache -- -- Idea is simple: cache information about packages built in other snapshots, -- and then for identical matches (same flags, config options, dependencies) -- just copy over the executables and reregister the libraries. -------------------------------------- -- | The file containing information on the given package/configuration -- combination. The filename contains a hash of the non-directory configure -- options for quick lookup if there's a match. -- -- It also returns an action yielding the location of the precompiled -- path based on the old binary encoding. -- -- We only pay attention to non-directory options. We don't want to avoid a -- cache hit just because it was installed in a different directory. precompiledCacheFile :: HasEnvConfig env => PackageLocationIndex FilePath -> ConfigureOpts -> Set GhcPkgId -- ^ dependencies -> RIO env (Maybe (Path Abs File)) precompiledCacheFile loc copts installedPackageIDs = do ec <- view envConfigL compiler <- view actualCompilerVersionL >>= parseRelDir . compilerVersionString cabal <- view cabalVersionL >>= parseRelDir . versionString let mpkgRaw = -- The goal here is to come up with a string representing the -- package location which is unique. For archives and repos, -- we rely upon cryptographic hashes paired with -- subdirectories to identify this specific package version. case loc of PLIndex pir -> Just $ packageIdentifierRevisionString pir PLOther other -> case other of PLFilePath _ -> assert False Nothing -- no PLFilePaths should end up in a snapshot PLArchive a -> fmap (\h -> T.unpack (staticSHA256ToText h) ++ archiveSubdirs a) (archiveHash a) PLRepo r -> Just $ T.unpack (repoCommit r) ++ repoSubdirs r forM mpkgRaw $ \pkgRaw -> do platformRelDir <- platformGhcRelDir let precompiledDir = view stackRootL ec $(mkRelDir "precompiled") platformRelDir compiler cabal pkg <- case parseRelDir pkgRaw of Just x -> return x Nothing -> parseRelDir $ T.unpack $ TE.decodeUtf8 $ B64URL.encode $ TE.encodeUtf8 $ T.pack pkgRaw -- In Cabal versions 1.22 and later, the configure options contain the -- installed package IDs, which is what we need for a unique hash. -- Unfortunately, earlier Cabals don't have the information, so we must -- supplement it with the installed package IDs directly. -- See issue: https://github.com/commercialhaskell/stack/issues/1103 let input = (coNoDirs copts, installedPackageIDs) hashPath <- parseRelFile $ S8.unpack $ B64URL.encode $ Mem.convert $ hashWith SHA256 $ Store.encode input let longPath = precompiledDir pkg hashPath -- See #3649 - shorten the paths on windows if MAX_PATH will be -- violated. Doing this only when necessary allows use of existing -- precompiled packages. if pathTooLong (toFilePath longPath) then do shortPkg <- shaPath pkg shortHash <- shaPath hashPath return $ precompiledDir shortPkg shortHash else return longPath -- | Write out information about a newly built package writePrecompiledCache :: HasEnvConfig env => BaseConfigOpts -> PackageLocationIndex FilePath -> ConfigureOpts -> Set GhcPkgId -- ^ dependencies -> Installed -- ^ library -> [GhcPkgId] -- ^ sublibraries, in the GhcPkgId format -> Set Text -- ^ executables -> RIO env () writePrecompiledCache baseConfigOpts loc copts depIDs mghcPkgId sublibs exes = do mfile <- precompiledCacheFile loc copts depIDs forM_ mfile $ \file -> do ensureDir (parent file) ec <- view envConfigL let stackRootRelative = makeRelative (view stackRootL ec) mlibpath <- case mghcPkgId of Executable _ -> return Nothing Library _ ipid _ -> liftM Just $ pathFromPkgId stackRootRelative ipid sublibpaths <- mapM (pathFromPkgId stackRootRelative) sublibs exes' <- forM (Set.toList exes) $ \exe -> do name <- parseRelFile $ T.unpack exe relPath <- stackRootRelative $ bcoSnapInstallRoot baseConfigOpts bindirSuffix name return $ toFilePath relPath $(versionedEncodeFile precompiledCacheVC) file PrecompiledCache { pcLibrary = mlibpath , pcSubLibs = sublibpaths , pcExes = exes' } where pathFromPkgId stackRootRelative ipid = do ipid' <- parseRelFile $ ghcPkgIdString ipid ++ ".conf" relPath <- stackRootRelative $ bcoSnapDB baseConfigOpts ipid' return $ toFilePath relPath -- | Check the cache for a precompiled package matching the given -- configuration. readPrecompiledCache :: forall env. HasEnvConfig env => PackageLocationIndex FilePath -- ^ target package -> ConfigureOpts -> Set GhcPkgId -- ^ dependencies -> RIO env (Maybe PrecompiledCache) readPrecompiledCache loc copts depIDs = runMaybeT $ MaybeT (precompiledCacheFile loc copts depIDs) >>= MaybeT . $(versionedDecodeFile precompiledCacheVC) >>= lift . mkAbs where -- Since commit ed9ccc08f327bad68dd2d09a1851ce0d055c0422, -- pcLibrary paths are stored as relative to the stack -- root. Therefore, we need to prepend the stack root when -- checking that the file exists. For the older cached paths, the -- file will contain an absolute path, which will make `stackRoot -- ` a no-op. mkAbs :: PrecompiledCache -> RIO env PrecompiledCache mkAbs pc0 = do stackRoot <- view stackRootL let mkAbs' = (toFilePath stackRoot FP.) return PrecompiledCache { pcLibrary = mkAbs' <$> pcLibrary pc0 , pcSubLibs = mkAbs' <$> pcSubLibs pc0 , pcExes = mkAbs' <$> pcExes pc0 } -- | Check if a filesystem path is too long. pathTooLong :: FilePath -> Bool #ifdef mingw32_HOST_OS pathTooLong path = utf16StringLength path >= win32MaxPath where win32MaxPath = 260 -- Calculate the length of a string in 16-bit units -- if it were converted to utf-16. utf16StringLength :: String -> Integer utf16StringLength = sum . map utf16CharLength where utf16CharLength c | ord c < 0x10000 = 1 | otherwise = 2 #else pathTooLong _ = False #endif stack-1.9.3.1/src/Stack/Build/ConstructPlan.hs0000644000000000000000000014533113455666157017235 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude #-} {-# OPTIONS_GHC -fno-warn-orphans #-} {-# LANGUAGE ConstraintKinds #-} {-# LANGUAGE DeriveDataTypeable #-} {-# LANGUAGE DeriveGeneric #-} {-# LANGUAGE FlexibleContexts #-} {-# LANGUAGE GeneralizedNewtypeDeriving #-} {-# LANGUAGE MultiParamTypeClasses #-} {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE RecordWildCards #-} {-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE TemplateHaskell #-} {-# LANGUAGE TupleSections #-} {-# LANGUAGE ViewPatterns #-} {-# LANGUAGE StandaloneDeriving #-} -- | Construct a @Plan@ for how to build module Stack.Build.ConstructPlan ( constructPlan ) where import Stack.Prelude hiding (Display (..)) import Control.Monad.RWS.Strict hiding ((<>)) import Control.Monad.State.Strict (execState) import qualified Data.HashSet as HashSet import qualified Data.HashMap.Strict as HashMap import Data.List import qualified Data.Map.Strict as M import qualified Data.Map.Strict as Map import Data.Monoid.Map (MonoidMap(..)) import qualified Data.Set as Set import qualified Data.Text as T import Data.Text.Encoding (encodeUtf8, decodeUtf8With) import Data.Text.Encoding.Error (lenientDecode) import qualified Distribution.Text as Cabal import qualified Distribution.Version as Cabal import Distribution.Types.BuildType (BuildType (Configure)) import Generics.Deriving.Monoid (memptydefault, mappenddefault) import qualified RIO import Stack.Build.Cache import Stack.Build.Haddock import Stack.Build.Installed import Stack.Build.Source import Stack.Constants import Stack.Package import Stack.PackageDump import Stack.PackageIndex import Stack.PrettyPrint import Stack.Types.Build import Stack.Types.BuildPlan import Stack.Types.Compiler import Stack.Types.Config import Stack.Types.FlagName import Stack.Types.GhcPkgId import Stack.Types.NamedComponent import Stack.Types.Package import Stack.Types.PackageIdentifier import Stack.Types.PackageName import Stack.Types.Runner import Stack.Types.Version import System.IO (putStrLn) import RIO.Process (findExecutable, HasProcessContext (..)) data PackageInfo = -- | This indicates that the package is already installed, and -- that we shouldn't build it from source. This is always the case -- for snapshot packages. PIOnlyInstalled InstallLocation Installed -- | This indicates that the package isn't installed, and we know -- where to find its source (either a hackage package or a local -- directory). | PIOnlySource PackageSource -- | This indicates that the package is installed and we know -- where to find its source. We may want to reinstall from source. | PIBoth PackageSource Installed deriving (Show) combineSourceInstalled :: PackageSource -> (InstallLocation, Installed) -> PackageInfo combineSourceInstalled ps (location, installed) = assert (piiVersion ps == installedVersion installed) $ assert (piiLocation ps == location) $ case location of -- Always trust something in the snapshot Snap -> PIOnlyInstalled location installed Local -> PIBoth ps installed type CombinedMap = Map PackageName PackageInfo combineMap :: SourceMap -> InstalledMap -> CombinedMap combineMap = Map.mergeWithKey (\_ s i -> Just $ combineSourceInstalled s i) (fmap PIOnlySource) (fmap (uncurry PIOnlyInstalled)) data AddDepRes = ADRToInstall Task | ADRFound InstallLocation Installed deriving Show type ParentMap = MonoidMap PackageName (First Version, [(PackageIdentifier, VersionRange)]) data W = W { wFinals :: !(Map PackageName (Either ConstructPlanException Task)) , wInstall :: !(Map Text InstallLocation) -- ^ executable to be installed, and location where the binary is placed , wDirty :: !(Map PackageName Text) -- ^ why a local package is considered dirty , wDeps :: !(Set PackageName) -- ^ Packages which count as dependencies , wWarnings :: !([Text] -> [Text]) -- ^ Warnings , wParents :: !ParentMap -- ^ Which packages a given package depends on, along with the package's version } deriving Generic instance Semigroup W where (<>) = mappenddefault instance Monoid W where mempty = memptydefault mappend = (<>) type M = RWST -- TODO replace with more efficient WS stack on top of StackT Ctx W (Map PackageName (Either ConstructPlanException AddDepRes)) IO data Ctx = Ctx { ls :: !LoadedSnapshot , baseConfigOpts :: !BaseConfigOpts , loadPackage :: !(PackageLocationIndex FilePath -> Map FlagName Bool -> [Text] -> M Package) , combinedMap :: !CombinedMap , ctxEnvConfig :: !EnvConfig , callStack :: ![PackageName] , extraToBuild :: !(Set PackageName) , getVersions :: !(PackageName -> IO (HashMap Version (Maybe CabalHash))) , wanted :: !(Set PackageName) , localNames :: !(Set PackageName) } instance HasPlatform Ctx instance HasGHCVariant Ctx instance HasLogFunc Ctx where logFuncL = configL.logFuncL instance HasRunner Ctx where runnerL = configL.runnerL instance HasConfig Ctx instance HasCabalLoader Ctx where cabalLoaderL = configL.cabalLoaderL instance HasProcessContext Ctx where processContextL = configL.processContextL instance HasBuildConfig Ctx instance HasEnvConfig Ctx where envConfigL = lens ctxEnvConfig (\x y -> x { ctxEnvConfig = y }) -- | Computes a build plan. This means figuring out which build 'Task's -- to take, and the interdependencies among the build 'Task's. In -- particular: -- -- 1) It determines which packages need to be built, based on the -- transitive deps of the current targets. For local packages, this is -- indicated by the 'lpWanted' boolean. For extra packages to build, -- this comes from the @extraToBuild0@ argument of type @Set -- PackageName@. These are usually packages that have been specified on -- the commandline. -- -- 2) It will only rebuild an upstream package if it isn't present in -- the 'InstalledMap', or if some of its dependencies have changed. -- -- 3) It will only rebuild a local package if its files are dirty or -- some of its dependencies have changed. constructPlan :: forall env. HasEnvConfig env => LoadedSnapshot -> BaseConfigOpts -> [LocalPackage] -> Set PackageName -- ^ additional packages that must be built -> [DumpPackage () () ()] -- ^ locally registered -> (PackageLocationIndex FilePath -> Map FlagName Bool -> [Text] -> RIO EnvConfig Package) -- ^ load upstream package -> SourceMap -> InstalledMap -> Bool -> RIO env Plan constructPlan ls0 baseConfigOpts0 locals extraToBuild0 localDumpPkgs loadPackage0 sourceMap installedMap initialBuildSteps = do logDebug "Constructing the build plan" bconfig <- view buildConfigL when (hasBaseInDeps bconfig) $ prettyWarn $ flow "You are trying to upgrade/downgrade base, which is almost certainly not what you really want. Please, consider using another GHC version if you need a certain version of base, or removing base from extra-deps. See more at https://github.com/commercialhaskell/stack/issues/3940." <> line econfig <- view envConfigL let onWanted = void . addDep False . packageName . lpPackage let inner = do mapM_ onWanted $ filter lpWanted locals mapM_ (addDep False) $ Set.toList extraToBuild0 let ctx = mkCtx econfig ((), m, W efinals installExes dirtyReason deps warnings parents) <- liftIO $ runRWST inner ctx M.empty mapM_ (logWarn . RIO.display) (warnings []) let toEither (_, Left e) = Left e toEither (k, Right v) = Right (k, v) (errlibs, adrs) = partitionEithers $ map toEither $ M.toList m (errfinals, finals) = partitionEithers $ map toEither $ M.toList efinals errs = errlibs ++ errfinals if null errs then do let toTask (_, ADRFound _ _) = Nothing toTask (name, ADRToInstall task) = Just (name, task) tasks = M.fromList $ mapMaybe toTask adrs takeSubset = case boptsCLIBuildSubset $ bcoBuildOptsCLI baseConfigOpts0 of BSAll -> id BSOnlySnapshot -> stripLocals BSOnlyDependencies -> stripNonDeps deps return $ takeSubset Plan { planTasks = tasks , planFinals = M.fromList finals , planUnregisterLocal = mkUnregisterLocal tasks dirtyReason localDumpPkgs sourceMap initialBuildSteps , planInstallExes = if boptsInstallExes (bcoBuildOpts baseConfigOpts0) || boptsInstallCompilerTool (bcoBuildOpts baseConfigOpts0) then installExes else Map.empty } else do planDebug $ show errs stackYaml <- view stackYamlL stackRoot <- view stackRootL prettyErrorNoIndent $ pprintExceptions errs stackYaml stackRoot parents (wanted ctx) throwM $ ConstructPlanFailed "Plan construction failed." where hasBaseInDeps bconfig = elem $(mkPackageName "base") $ map (packageIdentifierName . pirIdent) [i | (PLIndex i) <- bcDependencies bconfig] mkCtx econfig = Ctx { ls = ls0 , baseConfigOpts = baseConfigOpts0 , loadPackage = \x y z -> runRIO econfig $ loadPackage0 x y z , combinedMap = combineMap sourceMap installedMap , ctxEnvConfig = econfig , callStack = [] , extraToBuild = extraToBuild0 , getVersions = runRIO econfig . getPackageVersions , wanted = wantedLocalPackages locals <> extraToBuild0 , localNames = Set.fromList $ map (packageName . lpPackage) locals } -- | State to be maintained during the calculation of local packages -- to unregister. data UnregisterState = UnregisterState { usToUnregister :: !(Map GhcPkgId (PackageIdentifier, Text)) , usKeep :: ![DumpPackage () () ()] , usAnyAdded :: !Bool } -- | Determine which packages to unregister based on the given tasks and -- already registered local packages mkUnregisterLocal :: Map PackageName Task -- ^ Tasks -> Map PackageName Text -- ^ Reasons why packages are dirty and must be rebuilt -> [DumpPackage () () ()] -- ^ Local package database dump -> SourceMap -> Bool -- ^ If true, we're doing a special initialBuildSteps -- build - don't unregister target packages. -> Map GhcPkgId (PackageIdentifier, Text) mkUnregisterLocal tasks dirtyReason localDumpPkgs sourceMap initialBuildSteps = -- We'll take multiple passes through the local packages. This -- will allow us to detect that a package should be unregistered, -- as well as all packages directly or transitively depending on -- it. loop Map.empty localDumpPkgs where loop toUnregister keep -- If any new packages were added to the unregister Map, we -- need to loop through the remaining packages again to detect -- if a transitive dependency is being unregistered. | usAnyAdded us = loop (usToUnregister us) (usKeep us) -- Nothing added, so we've already caught them all. Return the -- Map we've already calculated. | otherwise = usToUnregister us where -- Run the unregister checking function on all packages we -- currently think we'll be keeping. us = execState (mapM_ go keep) UnregisterState { usToUnregister = toUnregister , usKeep = [] , usAnyAdded = False } go dp = do us <- get case go' (usToUnregister us) ident deps of -- Not unregistering, add it to the keep list Nothing -> put us { usKeep = dp : usKeep us } -- Unregistering, add it to the unregister Map and -- indicate that a package was in fact added to the -- unregister Map so we loop again. Just reason -> put us { usToUnregister = Map.insert gid (ident, reason) (usToUnregister us) , usAnyAdded = True } where gid = dpGhcPkgId dp ident = dpPackageIdent dp deps = dpDepends dp go' toUnregister ident deps -- If we're planning on running a task on it, then it must be -- unregistered, unless it's a target and an initial-build-steps -- build is being done. | Just task <- Map.lookup name tasks = if initialBuildSteps && taskIsTarget task && taskProvides task == ident then Nothing else Just $ fromMaybe "" $ Map.lookup name dirtyReason -- Check if we're no longer using the local version | Just (piiLocation -> Snap) <- Map.lookup name sourceMap = Just "Switching to snapshot installed package" -- Check if a dependency is going to be unregistered | (dep, _):_ <- mapMaybe (`Map.lookup` toUnregister) deps = Just $ "Dependency being unregistered: " <> packageIdentifierText dep -- None of the above, keep it! | otherwise = Nothing where name = packageIdentifierName ident -- | Given a 'LocalPackage' and its 'lpTestBench', adds a 'Task' for -- running its tests and benchmarks. -- -- If @isAllInOne@ is 'True', then this means that the build step will -- also build the tests. Otherwise, this indicates that there's a cyclic -- dependency and an additional build step needs to be done. -- -- This will also add all the deps needed to build the tests / -- benchmarks. If @isAllInOne@ is 'True' (the common case), then all of -- these should have already been taken care of as part of the build -- step. addFinal :: LocalPackage -> Package -> Bool -> M () addFinal lp package isAllInOne = do depsRes <- addPackageDeps False package res <- case depsRes of Left e -> return $ Left e Right (missing, present, _minLoc) -> do ctx <- ask return $ Right Task { taskProvides = PackageIdentifier (packageName package) (packageVersion package) , taskConfigOpts = TaskConfigOpts missing $ \missing' -> let allDeps = Map.union present missing' in configureOpts (view envConfigL ctx) (baseConfigOpts ctx) allDeps True -- local Local package , taskPresent = present , taskType = TTFiles lp Local -- FIXME we can rely on this being Local, right? , taskAllInOne = isAllInOne , taskCachePkgSrc = CacheSrcLocal (toFilePath (lpDir lp)) , taskAnyMissing = not $ Set.null missing , taskBuildTypeConfig = packageBuildTypeConfig package } tell mempty { wFinals = Map.singleton (packageName package) res } -- | Given a 'PackageName', adds all of the build tasks to build the -- package, if needed. -- -- 'constructPlan' invokes this on all the target packages, setting -- @treatAsDep'@ to False, because those packages are direct build -- targets. 'addPackageDeps' invokes this while recursing into the -- dependencies of a package. As such, it sets @treatAsDep'@ to True, -- forcing this package to be marked as a dependency, even if it is -- directly wanted. This makes sense - if we left out packages that are -- deps, it would break the --only-dependencies build plan. addDep :: Bool -- ^ is this being used by a dependency? -> PackageName -> M (Either ConstructPlanException AddDepRes) addDep treatAsDep' name = do ctx <- ask let treatAsDep = treatAsDep' || name `Set.notMember` wanted ctx when treatAsDep $ markAsDep name m <- get case Map.lookup name m of Just res -> do planDebug $ "addDep: Using cached result for " ++ show name ++ ": " ++ show res return res Nothing -> do res <- if name `elem` callStack ctx then do planDebug $ "addDep: Detected cycle " ++ show name ++ ": " ++ show (callStack ctx) return $ Left $ DependencyCycleDetected $ name : callStack ctx else local (\ctx' -> ctx' { callStack = name : callStack ctx' }) $ do let mpackageInfo = Map.lookup name $ combinedMap ctx planDebug $ "addDep: Package info for " ++ show name ++ ": " ++ show mpackageInfo case mpackageInfo of -- TODO look up in the package index and see if there's a -- recommendation available Nothing -> return $ Left $ UnknownPackage name Just (PIOnlyInstalled loc installed) -> do -- FIXME Slightly hacky, no flags since -- they likely won't affect executable -- names. This code does not feel right. tellExecutablesUpstream (PackageIdentifierRevision (PackageIdentifier name (installedVersion installed)) CFILatest) loc Map.empty return $ Right $ ADRFound loc installed Just (PIOnlySource ps) -> do tellExecutables ps installPackage treatAsDep name ps Nothing Just (PIBoth ps installed) -> do tellExecutables ps installPackage treatAsDep name ps (Just installed) updateLibMap name res return res -- FIXME what's the purpose of this? Add a Haddock! tellExecutables :: PackageSource -> M () tellExecutables (PSFiles lp _) | lpWanted lp = tellExecutablesPackage Local $ lpPackage lp | otherwise = return () -- Ignores ghcOptions because they don't matter for enumerating -- executables. tellExecutables (PSIndex loc flags _ghcOptions pir) = tellExecutablesUpstream pir loc flags tellExecutablesUpstream :: PackageIdentifierRevision -> InstallLocation -> Map FlagName Bool -> M () tellExecutablesUpstream pir@(PackageIdentifierRevision (PackageIdentifier name _) _) loc flags = do ctx <- ask when (name `Set.member` extraToBuild ctx) $ do p <- loadPackage ctx (PLIndex pir) flags [] tellExecutablesPackage loc p tellExecutablesPackage :: InstallLocation -> Package -> M () tellExecutablesPackage loc p = do cm <- asks combinedMap -- Determine which components are enabled so we know which ones to copy let myComps = case Map.lookup (packageName p) cm of Nothing -> assert False Set.empty Just (PIOnlyInstalled _ _) -> Set.empty Just (PIOnlySource ps) -> goSource ps Just (PIBoth ps _) -> goSource ps goSource (PSFiles lp _) | lpWanted lp = exeComponents (lpComponents lp) | otherwise = Set.empty goSource PSIndex{} = Set.empty tell mempty { wInstall = Map.fromList $ map (, loc) $ Set.toList $ filterComps myComps $ packageExes p } where filterComps myComps x | Set.null myComps = x | otherwise = Set.intersection x myComps -- | Given a 'PackageSource' and perhaps an 'Installed' value, adds -- build 'Task's for the package and its dependencies. installPackage :: Bool -- ^ is this being used by a dependency? -> PackageName -> PackageSource -> Maybe Installed -> M (Either ConstructPlanException AddDepRes) installPackage treatAsDep name ps minstalled = do ctx <- ask case ps of PSIndex _ flags ghcOptions pkgLoc -> do planDebug $ "installPackage: Doing all-in-one build for upstream package " ++ show name package <- loadPackage ctx (PLIndex pkgLoc) flags ghcOptions -- FIXME be more efficient! Get this from the LoadedPackageInfo! resolveDepsAndInstall True treatAsDep ps package minstalled PSFiles lp _ -> case lpTestBench lp of Nothing -> do planDebug $ "installPackage: No test / bench component for " ++ show name ++ " so doing an all-in-one build." resolveDepsAndInstall True treatAsDep ps (lpPackage lp) minstalled Just tb -> do -- Attempt to find a plan which performs an all-in-one -- build. Ignore the writer action + reset the state if -- it fails. s <- get res <- pass $ do res <- addPackageDeps treatAsDep tb let writerFunc w = case res of Left _ -> mempty _ -> w return (res, writerFunc) case res of Right deps -> do planDebug $ "installPackage: For " ++ show name ++ ", successfully added package deps" adr <- installPackageGivenDeps True ps tb minstalled deps -- FIXME: this redundantly adds the deps (but -- they'll all just get looked up in the map) addFinal lp tb True return $ Right adr Left _ -> do -- Reset the state to how it was before -- attempting to find an all-in-one build -- plan. planDebug $ "installPackage: Before trying cyclic plan, resetting lib result map to " ++ show s put s -- Otherwise, fall back on building the -- tests / benchmarks in a separate step. res' <- resolveDepsAndInstall False treatAsDep ps (lpPackage lp) minstalled when (isRight res') $ do -- Insert it into the map so that it's -- available for addFinal. updateLibMap name res' addFinal lp tb False return res' resolveDepsAndInstall :: Bool -> Bool -> PackageSource -> Package -> Maybe Installed -> M (Either ConstructPlanException AddDepRes) resolveDepsAndInstall isAllInOne treatAsDep ps package minstalled = do res <- addPackageDeps treatAsDep package case res of Left err -> return $ Left err Right deps -> liftM Right $ installPackageGivenDeps isAllInOne ps package minstalled deps -- | Checks if we need to install the given 'Package', given the results -- of 'addPackageDeps'. If dependencies are missing, the package is -- dirty, or it's not installed, then it needs to be installed. installPackageGivenDeps :: Bool -> PackageSource -> Package -> Maybe Installed -> ( Set PackageIdentifier , Map PackageIdentifier GhcPkgId , InstallLocation ) -> M AddDepRes installPackageGivenDeps isAllInOne ps package minstalled (missing, present, minLoc) = do let name = packageName package ctx <- ask mRightVersionInstalled <- case (minstalled, Set.null missing) of (Just installed, True) -> do shouldInstall <- checkDirtiness ps installed package present (wanted ctx) return $ if shouldInstall then Nothing else Just installed (Just _, False) -> do let t = T.intercalate ", " $ map (T.pack . packageNameString . packageIdentifierName) (Set.toList missing) tell mempty { wDirty = Map.singleton name $ "missing dependencies: " <> addEllipsis t } return Nothing (Nothing, _) -> return Nothing return $ case mRightVersionInstalled of Just installed -> ADRFound (piiLocation ps) installed Nothing -> ADRToInstall Task { taskProvides = PackageIdentifier (packageName package) (packageVersion package) , taskConfigOpts = TaskConfigOpts missing $ \missing' -> let allDeps = Map.union present missing' destLoc = piiLocation ps <> minLoc in configureOpts (view envConfigL ctx) (baseConfigOpts ctx) allDeps (psLocal ps) -- An assertion to check for a recurrence of -- https://github.com/commercialhaskell/stack/issues/345 (assert (destLoc == piiLocation ps) destLoc) package , taskPresent = present , taskType = case ps of PSFiles lp loc -> TTFiles lp (loc <> minLoc) PSIndex loc _ _ pkgLoc -> TTIndex package (loc <> minLoc) pkgLoc , taskAllInOne = isAllInOne , taskCachePkgSrc = toCachePkgSrc ps , taskAnyMissing = not $ Set.null missing , taskBuildTypeConfig = packageBuildTypeConfig package } -- | Is the build type of the package Configure packageBuildTypeConfig :: Package -> Bool packageBuildTypeConfig pkg = packageBuildType pkg == Configure -- Update response in the lib map. If it is an error, and there's -- already an error about cyclic dependencies, prefer the cyclic error. updateLibMap :: PackageName -> Either ConstructPlanException AddDepRes -> M () updateLibMap name val = modify $ \mp -> case (M.lookup name mp, val) of (Just (Left DependencyCycleDetected{}), Left _) -> mp _ -> M.insert name val mp addEllipsis :: Text -> Text addEllipsis t | T.length t < 100 = t | otherwise = T.take 97 t <> "..." -- | Given a package, recurses into all of its dependencies. The results -- indicate which packages are missing, meaning that their 'GhcPkgId's -- will be figured out during the build, after they've been built. The -- 2nd part of the tuple result indicates the packages that are already -- installed which will be used. -- -- The 3rd part of the tuple is an 'InstallLocation'. If it is 'Local', -- then the parent package must be installed locally. Otherwise, if it -- is 'Snap', then it can either be installed locally or in the -- snapshot. addPackageDeps :: Bool -- ^ is this being used by a dependency? -> Package -> M (Either ConstructPlanException (Set PackageIdentifier, Map PackageIdentifier GhcPkgId, InstallLocation)) addPackageDeps treatAsDep package = do ctx <- ask deps' <- packageDepsWithTools package deps <- forM (Map.toList deps') $ \(depname, DepValue range depType) -> do eres <- addDep treatAsDep depname let getLatestApplicableVersionAndRev = do vsAndRevs <- liftIO $ getVersions ctx depname let vs = Set.fromList (HashMap.keys vsAndRevs) case latestApplicableVersion range vs of Nothing -> pure Nothing Just lappVer -> do let mlappRev = join (HashMap.lookup lappVer vsAndRevs) pure $ (lappVer,) <$> mlappRev case eres of Left e -> do addParent depname range Nothing let bd = case e of UnknownPackage name -> assert (name == depname) NotInBuildPlan _ -> Couldn'tResolveItsDependencies (packageVersion package) mlatestApplicable <- getLatestApplicableVersionAndRev return $ Left (depname, (range, mlatestApplicable, bd)) Right adr | depType == AsLibrary && not (adrHasLibrary adr) -> return $ Left (depname, (range, Nothing, HasNoLibrary)) Right adr -> do addParent depname range Nothing inRange <- if adrVersion adr `withinRange` range then return True else do let warn_ reason = tell mempty { wWarnings = (msg:) } where msg = T.concat [ "WARNING: Ignoring out of range dependency" , reason , ": " , T.pack $ packageIdentifierString $ PackageIdentifier depname (adrVersion adr) , ". " , T.pack $ packageNameString $ packageName package , " requires: " , versionRangeText range ] allowNewer <- view $ configL.to configAllowNewer if allowNewer then do warn_ " (allow-newer enabled)" return True else do x <- inSnapshot (packageName package) (packageVersion package) y <- inSnapshot depname (adrVersion adr) if x && y then do warn_ " (trusting snapshot over Hackage revisions)" return True else return False if inRange then case adr of ADRToInstall task -> return $ Right (Set.singleton $ taskProvides task, Map.empty, taskLocation task) ADRFound loc (Executable _) -> return $ Right (Set.empty, Map.empty, loc) ADRFound loc (Library ident gid _) -> return $ Right (Set.empty, Map.singleton ident gid, loc) else do mlatestApplicable <- getLatestApplicableVersionAndRev return $ Left (depname, (range, mlatestApplicable, DependencyMismatch $ adrVersion adr)) case partitionEithers deps of -- Note that the Monoid for 'InstallLocation' means that if any -- is 'Local', the result is 'Local', indicating that the parent -- package must be installed locally. Otherwise the result is -- 'Snap', indicating that the parent can either be installed -- locally or in the snapshot. ([], pairs) -> return $ Right $ mconcat pairs (errs, _) -> return $ Left $ DependencyPlanFailures package (Map.fromList errs) where adrVersion (ADRToInstall task) = packageIdentifierVersion $ taskProvides task adrVersion (ADRFound _ installed) = installedVersion installed -- Update the parents map, for later use in plan construction errors -- - see 'getShortestDepsPath'. addParent depname range mversion = tell mempty { wParents = MonoidMap $ M.singleton depname val } where val = (First mversion, [(packageIdentifier package, range)]) adrHasLibrary :: AddDepRes -> Bool adrHasLibrary (ADRToInstall task) = taskHasLibrary task adrHasLibrary (ADRFound _ Library{}) = True adrHasLibrary (ADRFound _ Executable{}) = False taskHasLibrary :: Task -> Bool taskHasLibrary task = case taskType task of TTFiles lp _ -> packageHasLibrary $ lpPackage lp TTIndex p _ _ -> packageHasLibrary p -- make sure we consider internal libraries as libraries too packageHasLibrary :: Package -> Bool packageHasLibrary p = not (Set.null (packageInternalLibraries p)) || case packageLibraries p of HasLibraries _ -> True NoLibraries -> False checkDirtiness :: PackageSource -> Installed -> Package -> Map PackageIdentifier GhcPkgId -> Set PackageName -> M Bool checkDirtiness ps installed package present wanted = do ctx <- ask moldOpts <- runRIO ctx $ tryGetFlagCache installed let configOpts = configureOpts (view envConfigL ctx) (baseConfigOpts ctx) present (psLocal ps) (piiLocation ps) -- should be Local always package buildOpts = bcoBuildOpts (baseConfigOpts ctx) wantConfigCache = ConfigCache { configCacheOpts = configOpts , configCacheDeps = Set.fromList $ Map.elems present , configCacheComponents = case ps of PSFiles lp _ -> Set.map (encodeUtf8 . renderComponent) $ lpComponents lp PSIndex{} -> Set.empty , configCacheHaddock = shouldHaddockPackage buildOpts wanted (packageName package) || -- Disabling haddocks when old config had haddocks doesn't make dirty. maybe False configCacheHaddock moldOpts , configCachePkgSrc = toCachePkgSrc ps } let mreason = case moldOpts of Nothing -> Just "old configure information not found" Just oldOpts | Just reason <- describeConfigDiff config oldOpts wantConfigCache -> Just reason | True <- psForceDirty ps -> Just "--force-dirty specified" | Just files <- psDirty ps -> Just $ "local file changes: " <> addEllipsis (T.pack $ unwords $ Set.toList files) | otherwise -> Nothing config = view configL ctx case mreason of Nothing -> return False Just reason -> do tell mempty { wDirty = Map.singleton (packageName package) reason } return True describeConfigDiff :: Config -> ConfigCache -> ConfigCache -> Maybe Text describeConfigDiff config old new | configCachePkgSrc old /= configCachePkgSrc new = Just $ "switching from " <> pkgSrcName (configCachePkgSrc old) <> " to " <> pkgSrcName (configCachePkgSrc new) | not (configCacheDeps new `Set.isSubsetOf` configCacheDeps old) = Just "dependencies changed" | not $ Set.null newComponents = Just $ "components added: " `T.append` T.intercalate ", " (map (decodeUtf8With lenientDecode) (Set.toList newComponents)) | not (configCacheHaddock old) && configCacheHaddock new = Just "rebuilding with haddocks" | oldOpts /= newOpts = Just $ T.pack $ concat [ "flags changed from " , show oldOpts , " to " , show newOpts ] | otherwise = Nothing where stripGhcOptions = go where go [] = [] go ("--ghc-option":x:xs) = go' Ghc x xs go ("--ghc-options":x:xs) = go' Ghc x xs go ((T.stripPrefix "--ghc-option=" -> Just x):xs) = go' Ghc x xs go ((T.stripPrefix "--ghc-options=" -> Just x):xs) = go' Ghc x xs go ("--ghcjs-option":x:xs) = go' Ghcjs x xs go ("--ghcjs-options":x:xs) = go' Ghcjs x xs go ((T.stripPrefix "--ghcjs-option=" -> Just x):xs) = go' Ghcjs x xs go ((T.stripPrefix "--ghcjs-options=" -> Just x):xs) = go' Ghcjs x xs go (x:xs) = x : go xs go' wc x xs = checkKeepers wc x $ go xs checkKeepers wc x xs = case filter isKeeper $ T.words x of [] -> xs keepers -> T.pack (compilerOptionsCabalFlag wc) : T.unwords keepers : xs -- GHC options which affect build results and therefore should always -- force a rebuild -- -- For the most part, we only care about options generated by Stack -- itself isKeeper = (== "-fhpc") -- more to be added later userOpts = filter (not . isStackOpt) . (if configRebuildGhcOptions config then id else stripGhcOptions) . map T.pack . (\(ConfigureOpts x y) -> x ++ y) . configCacheOpts (oldOpts, newOpts) = removeMatching (userOpts old) (userOpts new) removeMatching (x:xs) (y:ys) | x == y = removeMatching xs ys removeMatching xs ys = (xs, ys) newComponents = configCacheComponents new `Set.difference` configCacheComponents old pkgSrcName (CacheSrcLocal fp) = T.pack fp pkgSrcName CacheSrcUpstream = "upstream source" psForceDirty :: PackageSource -> Bool psForceDirty (PSFiles lp _) = lpForceDirty lp psForceDirty PSIndex{} = False psDirty :: PackageSource -> Maybe (Set FilePath) psDirty (PSFiles lp _) = lpDirtyFiles lp psDirty PSIndex{} = Nothing -- files never change in an upstream package psLocal :: PackageSource -> Bool psLocal (PSFiles _ loc) = loc == Local -- FIXME this is probably not the right logic, see configureOptsNoDir. We probably want to check if this appears in packages: psLocal PSIndex{} = False -- | Get all of the dependencies for a given package, including build -- tool dependencies. packageDepsWithTools :: Package -> M (Map PackageName DepValue) packageDepsWithTools p = do -- Check whether the tool is on the PATH before warning about it. warnings <- fmap catMaybes $ forM (Set.toList $ packageUnknownTools p) $ \name@(ExeName toolName) -> do let settings = minimalEnvSettings { esIncludeLocals = True } config <- view configL menv <- liftIO $ configProcessContextSettings config settings mfound <- runRIO menv $ findExecutable $ T.unpack toolName case mfound of Left _ -> return $ Just $ ToolWarning name (packageName p) Right _ -> return Nothing tell mempty { wWarnings = (map toolWarningText warnings ++) } return $ packageDeps p -- | Warn about tools in the snapshot definition. States the tool name -- expected and the package name using it. data ToolWarning = ToolWarning ExeName PackageName deriving Show toolWarningText :: ToolWarning -> Text toolWarningText (ToolWarning (ExeName toolName) pkgName) = "No packages found in snapshot which provide a " <> T.pack (show toolName) <> " executable, which is a build-tool dependency of " <> T.pack (show (packageNameString pkgName)) -- | Strip out anything from the @Plan@ intended for the local database stripLocals :: Plan -> Plan stripLocals plan = plan { planTasks = Map.filter checkTask $ planTasks plan , planFinals = Map.empty , planUnregisterLocal = Map.empty , planInstallExes = Map.filter (/= Local) $ planInstallExes plan } where checkTask task = taskLocation task == Snap stripNonDeps :: Set PackageName -> Plan -> Plan stripNonDeps deps plan = plan { planTasks = Map.filter checkTask $ planTasks plan , planFinals = Map.empty , planInstallExes = Map.empty -- TODO maybe don't disable this? } where checkTask task = packageIdentifierName (taskProvides task) `Set.member` deps markAsDep :: PackageName -> M () markAsDep name = tell mempty { wDeps = Set.singleton name } -- | Is the given package/version combo defined in the snapshot? inSnapshot :: PackageName -> Version -> M Bool inSnapshot name version = do p <- asks ls ls <- asks localNames return $ fromMaybe False $ do guard $ not $ name `Set.member` ls lpi <- Map.lookup name (lsPackages p) return $ lpiVersion lpi == version data ConstructPlanException = DependencyCycleDetected [PackageName] | DependencyPlanFailures Package (Map PackageName (VersionRange, LatestApplicableVersion, BadDependency)) | UnknownPackage PackageName -- TODO perhaps this constructor will be removed, and BadDependency will handle it all -- ^ Recommend adding to extra-deps, give a helpful version number? deriving (Typeable, Eq, Ord, Show) deriving instance Ord VersionRange -- | The latest applicable version and it's latest cabal file revision. -- For display purposes only, Nothing if package not found type LatestApplicableVersion = Maybe (Version, CabalHash) -- | Reason why a dependency was not used data BadDependency = NotInBuildPlan | Couldn'tResolveItsDependencies Version | DependencyMismatch Version | HasNoLibrary -- ^ See description of 'DepType' deriving (Typeable, Eq, Ord, Show) -- TODO: Consider intersecting version ranges for multiple deps on a -- package. This is why VersionRange is in the parent map. pprintExceptions :: [ConstructPlanException] -> Path Abs File -> Path Abs Dir -> ParentMap -> Set PackageName -> AnsiDoc pprintExceptions exceptions stackYaml stackRoot parentMap wanted = mconcat $ [ flow "While constructing the build plan, the following exceptions were encountered:" , line <> line , mconcat (intersperse (line <> line) (mapMaybe pprintException exceptions')) , line <> line , flow "Some different approaches to resolving this:" , line <> line ] ++ (if not onlyHasDependencyMismatches then [] else [ " *" <+> align (flow "Set 'allow-newer: true' in " <+> toAnsiDoc (display (defaultUserConfigPath stackRoot)) <+> "to ignore all version constraints and build anyway.") , line <> line ] ) ++ [ " *" <+> align (flow "Consider trying 'stack solver', which uses the cabal-install solver to attempt to find some working build configuration. This can be convenient when dealing with many complicated constraint errors, but results may be unpredictable.") , line <> line ] ++ addExtraDepsRecommendations where exceptions' = nubOrd exceptions addExtraDepsRecommendations | Map.null extras = [] | (Just _) <- Map.lookup $(mkPackageName "base") extras = [ " *" <+> align (flow "Build requires unattainable version of base. Since base is a part of GHC, you most likely need to use a different GHC version with the matching base.") , line ] | otherwise = [ " *" <+> align (styleRecommendation (flow "Recommended action:") <+> flow "try adding the following to your extra-deps in" <+> toAnsiDoc (display stackYaml) <> ":") , line <> line , vsep (map pprintExtra (Map.toList extras)) , line ] extras = Map.unions $ map getExtras exceptions' getExtras DependencyCycleDetected{} = Map.empty getExtras UnknownPackage{} = Map.empty getExtras (DependencyPlanFailures _ m) = Map.unions $ map go $ Map.toList m where -- TODO: Likely a good idea to distinguish these to the user. In particular, for DependencyMismatch go (name, (_range, Just (version,cabalHash), NotInBuildPlan)) = Map.singleton name (version,cabalHash) go (name, (_range, Just (version,cabalHash), DependencyMismatch{})) = Map.singleton name (version, cabalHash) go _ = Map.empty pprintExtra (name, (version, cabalHash)) = let cfInfo = CFIHash Nothing cabalHash packageId = PackageIdentifier name version packageIdRev = PackageIdentifierRevision packageId cfInfo in fromString $ packageIdentifierRevisionString packageIdRev allNotInBuildPlan = Set.fromList $ concatMap toNotInBuildPlan exceptions' toNotInBuildPlan (DependencyPlanFailures _ pDeps) = map fst $ filter (\(_, (_, _, badDep)) -> badDep == NotInBuildPlan) $ Map.toList pDeps toNotInBuildPlan _ = [] -- This checks if 'allow-newer: true' could resolve all issues. onlyHasDependencyMismatches = all go exceptions' where go DependencyCycleDetected{} = False go UnknownPackage{} = False go (DependencyPlanFailures _ m) = all (\(_, _, depErr) -> isMismatch depErr) (M.elems m) isMismatch DependencyMismatch{} = True isMismatch Couldn'tResolveItsDependencies{} = True isMismatch _ = False pprintException (DependencyCycleDetected pNames) = Just $ flow "Dependency cycle detected in packages:" <> line <> indent 4 (encloseSep "[" "]" "," (map (styleError . display) pNames)) pprintException (DependencyPlanFailures pkg pDeps) = case mapMaybe pprintDep (Map.toList pDeps) of [] -> Nothing depErrors -> Just $ flow "In the dependencies for" <+> pkgIdent <> pprintFlags (packageFlags pkg) <> ":" <> line <> indent 4 (vsep depErrors) <> case getShortestDepsPath parentMap wanted (packageName pkg) of Nothing -> line <> flow "needed for unknown reason - stack invariant violated." Just [] -> line <> flow "needed since" <+> pkgName <+> flow "is a build target." Just (target:path) -> line <> flow "needed due to" <+> encloseSep "" "" " -> " pathElems where pathElems = [styleTarget . display $ target] ++ map display path ++ [pkgIdent] where pkgName = styleCurrent . display $ packageName pkg pkgIdent = styleCurrent . display $ packageIdentifier pkg -- Skip these when they are redundant with 'NotInBuildPlan' info. pprintException (UnknownPackage name) | name `Set.member` allNotInBuildPlan = Nothing | name `HashSet.member` wiredInPackages = Just $ flow "Can't build a package with same name as a wired-in-package:" <+> (styleCurrent . display $ name) | otherwise = Just $ flow "Unknown package:" <+> (styleCurrent . display $ name) pprintFlags flags | Map.null flags = "" | otherwise = parens $ sep $ map pprintFlag $ Map.toList flags pprintFlag (name, True) = "+" <> fromString (show name) pprintFlag (name, False) = "-" <> fromString (show name) pprintDep (name, (range, mlatestApplicable, badDep)) = case badDep of NotInBuildPlan -> Just $ styleError (display name) <+> align ((if range == Cabal.anyVersion then flow "needed" else flow "must match" <+> goodRange) <> "," <> softline <> flow "but the stack configuration has no specified version" <+> latestApplicable Nothing) -- TODO: For local packages, suggest editing constraints DependencyMismatch version -> Just $ (styleError . display) (PackageIdentifier name version) <+> align (flow "from stack configuration does not match" <+> goodRange <+> latestApplicable (Just version)) -- I think the main useful info is these explain why missing -- packages are needed. Instead lets give the user the shortest -- path from a target to the package. Couldn'tResolveItsDependencies _version -> Nothing HasNoLibrary -> Just $ styleError (display name) <+> align (flow "is a library dependency, but the package provides no library") where goodRange = styleGood (fromString (Cabal.display range)) latestApplicable mversion = case mlatestApplicable of Nothing | isNothing mversion -> flow "(no package with that name found, perhaps there is a typo in a package's build-depends or an omission from the stack.yaml packages list?)" | otherwise -> "" Just (laVer, _) | Just laVer == mversion -> softline <> flow "(latest matching version is specified)" | otherwise -> softline <> flow "(latest matching version is" <+> styleGood (display laVer) <> ")" -- | Get the shortest reason for the package to be in the build plan. In -- other words, trace the parent dependencies back to a 'wanted' -- package. getShortestDepsPath :: ParentMap -> Set PackageName -> PackageName -> Maybe [PackageIdentifier] getShortestDepsPath (MonoidMap parentsMap) wanted name = if Set.member name wanted then Just [] else case M.lookup name parentsMap of Nothing -> Nothing Just (_, parents) -> Just $ findShortest 256 paths0 where paths0 = M.fromList $ map (\(ident, _) -> (packageIdentifierName ident, startDepsPath ident)) parents where -- The 'paths' map is a map from PackageName to the shortest path -- found to get there. It is the frontier of our breadth-first -- search of dependencies. findShortest :: Int -> Map PackageName DepsPath -> [PackageIdentifier] findShortest fuel _ | fuel <= 0 = [PackageIdentifier $(mkPackageName "stack-ran-out-of-jet-fuel") $(mkVersion "0")] findShortest _ paths | M.null paths = [] findShortest fuel paths = case targets of [] -> findShortest (fuel - 1) $ M.fromListWith chooseBest $ concatMap extendPath recurses _ -> let (DepsPath _ _ path) = minimum (map snd targets) in path where (targets, recurses) = partition (\(n, _) -> n `Set.member` wanted) (M.toList paths) chooseBest :: DepsPath -> DepsPath -> DepsPath chooseBest x y = if x > y then x else y -- Extend a path to all its parents. extendPath :: (PackageName, DepsPath) -> [(PackageName, DepsPath)] extendPath (n, dp) = case M.lookup n parentsMap of Nothing -> [] Just (_, parents) -> map (\(pkgId, _) -> (packageIdentifierName pkgId, extendDepsPath pkgId dp)) parents data DepsPath = DepsPath { dpLength :: Int -- ^ Length of dpPath , dpNameLength :: Int -- ^ Length of package names combined , dpPath :: [PackageIdentifier] -- ^ A path where the packages later -- in the list depend on those that -- come earlier } deriving (Eq, Ord, Show) startDepsPath :: PackageIdentifier -> DepsPath startDepsPath ident = DepsPath { dpLength = 1 , dpNameLength = T.length (packageNameText (packageIdentifierName ident)) , dpPath = [ident] } extendDepsPath :: PackageIdentifier -> DepsPath -> DepsPath extendDepsPath ident dp = DepsPath { dpLength = dpLength dp + 1 , dpNameLength = dpNameLength dp + T.length (packageNameText (packageIdentifierName ident)) , dpPath = [ident] } -- Switch this to 'True' to enable some debugging putStrLn in this module planDebug :: MonadIO m => String -> m () planDebug = if False then liftIO . putStrLn else \_ -> return () stack-1.9.3.1/src/Stack/Build/Execute.hs0000644000000000000000000027352513455617610016035 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude #-} {-# LANGUAGE CPP #-} {-# LANGUAGE ConstraintKinds #-} {-# LANGUAGE DataKinds #-} {-# LANGUAGE FlexibleContexts #-} {-# LANGUAGE MultiParamTypeClasses #-} {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE RecordWildCards #-} {-# LANGUAGE TemplateHaskell #-} {-# LANGUAGE LambdaCase #-} {-# LANGUAGE TypeFamilies #-} {-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE RankNTypes #-} {-# LANGUAGE TupleSections #-} -- | Perform a build module Stack.Build.Execute ( printPlan , preFetch , executePlan -- * Running Setup.hs , ExecuteEnv , withExecuteEnv , withSingleContext , ExcludeTHLoading(..) ) where import Control.Concurrent.Execute import Control.Concurrent.STM (check) import Stack.Prelude hiding (Display (..)) import Crypto.Hash import Data.Attoparsec.Text hiding (try) import qualified Data.ByteArray as Mem (convert) import qualified Data.ByteString as S import qualified Data.ByteString.Base64.URL as B64URL import Data.Char (isSpace) import Data.Conduit import qualified Data.Conduit.Binary as CB import qualified Data.Conduit.List as CL import Data.Conduit.Process.Typed (ExitCodeException (..), waitExitCode, useHandleOpen, setStdin, setStdout, setStderr, getStdin, createPipe, runProcess_, getStdout, getStderr, createSource) import qualified Data.Conduit.Text as CT import Data.FileEmbed (embedFile, makeRelativeToProject) import Data.IORef.RunOnce (runOnce) import Data.List hiding (any) import qualified Data.Map.Strict as M import qualified Data.Map.Strict as Map import qualified Data.Set as Set import qualified Data.Text as T import Data.Text.Encoding (decodeUtf8, encodeUtf8) import Data.Time.Clock (getCurrentTime) import Data.Tuple import qualified Distribution.PackageDescription as C import qualified Distribution.Simple.Build.Macros as C import Distribution.System (OS (Windows), Platform (Platform)) import qualified Distribution.Text as C import Path import Path.CheckInstall import Path.Extra (toFilePathNoTrailingSep, rejectMissingFile) import Path.IO hiding (findExecutable, makeAbsolute, withSystemTempDir) import qualified RIO import Stack.Build.Cache import Stack.Build.Haddock import Stack.Build.Installed import Stack.Build.Source import Stack.Build.Target import Stack.Config import Stack.Constants import Stack.Constants.Config import Stack.Coverage import Stack.Fetch as Fetch import Stack.GhcPkg import Stack.Package import Stack.PackageDump import Stack.PrettyPrint import Stack.Types.Build import Stack.Types.Compiler import Stack.Types.Config import Stack.Types.GhcPkgId import Stack.Types.NamedComponent import Stack.Types.Package import Stack.Types.PackageIdentifier import Stack.Types.PackageName import Stack.Types.Runner import Stack.Types.Version import qualified System.Directory as D import System.Environment (getExecutablePath) import System.Exit (ExitCode (..)) import qualified System.FilePath as FP import System.IO (hPutStr, stderr, stdout) import System.PosixCompat.Files (createLink) import RIO.Process -- | Has an executable been built or not? data ExecutableBuildStatus = ExecutableBuilt | ExecutableNotBuilt deriving (Show, Eq, Ord) -- | Fetch the packages necessary for a build, for example in combination with a dry run. preFetch :: HasEnvConfig env => Plan -> RIO env () preFetch plan | Set.null idents = logDebug "Nothing to fetch" | otherwise = do logDebug $ "Prefetching: " <> mconcat (intersperse ", " (RIO.display <$> Set.toList idents)) fetchPackages idents where idents = Set.unions $ map toIdent $ Map.elems $ planTasks plan toIdent task = case taskType task of TTFiles{} -> Set.empty TTIndex _ _ (PackageIdentifierRevision ident _) -> Set.singleton ident -- | Print a description of build plan for human consumption. printPlan :: HasRunner env => Plan -> RIO env () printPlan plan = do case Map.elems $ planUnregisterLocal plan of [] -> logInfo "No packages would be unregistered." xs -> do logInfo "Would unregister locally:" forM_ xs $ \(ident, reason) -> logInfo $ RIO.display ident <> if T.null reason then "" else " (" <> RIO.display reason <> ")" logInfo "" case Map.elems $ planTasks plan of [] -> logInfo "Nothing to build." xs -> do logInfo "Would build:" mapM_ (logInfo . displayTask) xs let hasTests = not . Set.null . testComponents . taskComponents hasBenches = not . Set.null . benchComponents . taskComponents tests = Map.elems $ Map.filter hasTests $ planFinals plan benches = Map.elems $ Map.filter hasBenches $ planFinals plan unless (null tests) $ do logInfo "" logInfo "Would test:" mapM_ (logInfo . displayTask) tests unless (null benches) $ do logInfo "" logInfo "Would benchmark:" mapM_ (logInfo . displayTask) benches logInfo "" case Map.toList $ planInstallExes plan of [] -> logInfo "No executables to be installed." xs -> do logInfo "Would install executables:" forM_ xs $ \(name, loc) -> logInfo $ RIO.display name <> " from " <> (case loc of Snap -> "snapshot" Local -> "local") <> " database" -- | For a dry run displayTask :: Task -> Utf8Builder displayTask task = RIO.display (taskProvides task) <> ": database=" <> (case taskLocation task of Snap -> "snapshot" Local -> "local") <> ", source=" <> (case taskType task of TTFiles lp _ -> fromString $ toFilePath $ lpDir lp TTIndex{} -> "package index") <> (if Set.null missing then "" else ", after: " <> mconcat (intersperse "," (RIO.display <$> Set.toList missing))) where missing = tcoMissing $ taskConfigOpts task data ExecuteEnv = ExecuteEnv { eeConfigureLock :: !(MVar ()) , eeInstallLock :: !(MVar ()) , eeBuildOpts :: !BuildOpts , eeBuildOptsCLI :: !BuildOptsCLI , eeBaseConfigOpts :: !BaseConfigOpts , eeGhcPkgIds :: !(TVar (Map PackageIdentifier Installed)) , eeTempDir :: !(Path Abs Dir) , eeSetupHs :: !(Path Abs File) -- ^ Temporary Setup.hs for simple builds , eeSetupShimHs :: !(Path Abs File) -- ^ Temporary SetupShim.hs, to provide access to initial-build-steps , eeSetupExe :: !(Maybe (Path Abs File)) -- ^ Compiled version of eeSetupHs , eeCabalPkgVer :: !Version , eeTotalWanted :: !Int , eeWanted :: !(Set PackageName) , eeLocals :: ![LocalPackage] , eeGlobalDB :: !(Path Abs Dir) , eeGlobalDumpPkgs :: !(Map GhcPkgId (DumpPackage () () ())) , eeSnapshotDumpPkgs :: !(TVar (Map GhcPkgId (DumpPackage () () ()))) , eeLocalDumpPkgs :: !(TVar (Map GhcPkgId (DumpPackage () () ()))) , eeLogFiles :: !(TChan (Path Abs Dir, Path Abs File)) , eeGetGhcPath :: !(forall m. MonadIO m => m (Path Abs File)) , eeGetGhcjsPath :: !(forall m. MonadIO m => m (Path Abs File)) , eeCustomBuilt :: !(IORef (Set PackageName)) -- ^ Stores which packages with custom-setup have already had their -- Setup.hs built. } buildSetupArgs :: [String] buildSetupArgs = [ "-rtsopts" , "-threaded" , "-clear-package-db" , "-global-package-db" , "-hide-all-packages" , "-package" , "base" , "-main-is" , "StackSetupShim.mainOverride" ] setupGhciShimCode :: S.ByteString setupGhciShimCode = $(do path <- makeRelativeToProject "src/setup-shim/StackSetupShim.hs" embedFile path) simpleSetupCode :: S.ByteString simpleSetupCode = "import Distribution.Simple\nmain = defaultMain" simpleSetupHash :: String simpleSetupHash = T.unpack $ decodeUtf8 $ S.take 8 $ B64URL.encode $ Mem.convert $ hashWith SHA256 $ encodeUtf8 (T.pack (unwords buildSetupArgs)) <> setupGhciShimCode <> simpleSetupCode -- | Get a compiled Setup exe getSetupExe :: HasEnvConfig env => Path Abs File -- ^ Setup.hs input file -> Path Abs File -- ^ SetupShim.hs input file -> Path Abs Dir -- ^ temporary directory -> RIO env (Maybe (Path Abs File)) getSetupExe setupHs setupShimHs tmpdir = do wc <- view $ actualCompilerVersionL.whichCompilerL platformDir <- platformGhcRelDir config <- view configL cabalVersionString <- view $ cabalVersionL.to versionString actualCompilerVersionString <- view $ actualCompilerVersionL.to compilerVersionString platform <- view platformL let baseNameS = concat [ "Cabal-simple_" , simpleSetupHash , "_" , cabalVersionString , "_" , actualCompilerVersionString ] exeNameS = baseNameS ++ case platform of Platform _ Windows -> ".exe" _ -> "" outputNameS = case wc of Ghc -> exeNameS Ghcjs -> baseNameS ++ ".jsexe" jsExeNameS = baseNameS ++ ".jsexe" setupDir = view stackRootL config $(mkRelDir "setup-exe-cache") platformDir exePath <- (setupDir ) <$> parseRelFile exeNameS jsExePath <- (setupDir ) <$> parseRelDir jsExeNameS exists <- liftIO $ D.doesFileExist $ toFilePath exePath if exists then return $ Just exePath else do tmpExePath <- fmap (setupDir ) $ parseRelFile $ "tmp-" ++ exeNameS tmpOutputPath <- fmap (setupDir ) $ parseRelFile $ "tmp-" ++ outputNameS tmpJsExePath <- fmap (setupDir ) $ parseRelDir $ "tmp-" ++ jsExeNameS ensureDir setupDir let args = buildSetupArgs ++ [ "-package" , "Cabal-" ++ cabalVersionString , toFilePath setupHs , toFilePath setupShimHs , "-o" , toFilePath tmpOutputPath ] ++ ["-build-runner" | wc == Ghcjs] withWorkingDir (toFilePath tmpdir) (proc (compilerExeName wc) args $ \pc0 -> do let pc = setStdout (useHandleOpen stderr) pc0 runProcess_ pc) `catch` \ece -> do compilerPath <- getCompilerPath wc throwM $ SetupHsBuildFailure (eceExitCode ece) Nothing compilerPath args Nothing [] when (wc == Ghcjs) $ renameDir tmpJsExePath jsExePath renameFile tmpExePath exePath return $ Just exePath -- | Execute a function that takes an 'ExecuteEnv'. withExecuteEnv :: forall env a. HasEnvConfig env => BuildOpts -> BuildOptsCLI -> BaseConfigOpts -> [LocalPackage] -> [DumpPackage () () ()] -- ^ global packages -> [DumpPackage () () ()] -- ^ snapshot packages -> [DumpPackage () () ()] -- ^ local packages -> (ExecuteEnv -> RIO env a) -> RIO env a withExecuteEnv bopts boptsCli baseConfigOpts locals globalPackages snapshotPackages localPackages inner = createTempDirFunction stackProgName $ \tmpdir -> do configLock <- liftIO $ newMVar () installLock <- liftIO $ newMVar () idMap <- liftIO $ newTVarIO Map.empty config <- view configL getGhcPath <- runOnce $ getCompilerPath Ghc getGhcjsPath <- runOnce $ getCompilerPath Ghcjs customBuiltRef <- newIORef Set.empty -- Create files for simple setup and setup shim, if necessary let setupSrcDir = view stackRootL config $(mkRelDir "setup-exe-src") ensureDir setupSrcDir setupFileName <- parseRelFile ("setup-" ++ simpleSetupHash ++ ".hs") let setupHs = setupSrcDir setupFileName setupHsExists <- doesFileExist setupHs unless setupHsExists $ liftIO $ S.writeFile (toFilePath setupHs) simpleSetupCode setupShimFileName <- parseRelFile ("setup-shim-" ++ simpleSetupHash ++ ".hs") let setupShimHs = setupSrcDir setupShimFileName setupShimHsExists <- doesFileExist setupShimHs unless setupShimHsExists $ liftIO $ S.writeFile (toFilePath setupShimHs) setupGhciShimCode setupExe <- getSetupExe setupHs setupShimHs tmpdir cabalPkgVer <- view cabalVersionL globalDB <- getGlobalDB =<< view (actualCompilerVersionL.whichCompilerL) snapshotPackagesTVar <- liftIO $ newTVarIO (toDumpPackagesByGhcPkgId snapshotPackages) localPackagesTVar <- liftIO $ newTVarIO (toDumpPackagesByGhcPkgId localPackages) logFilesTChan <- liftIO $ atomically newTChan let totalWanted = length $ filter lpWanted locals env <- ask inner ExecuteEnv { eeBuildOpts = bopts , eeBuildOptsCLI = boptsCli -- Uncertain as to why we cannot run configures in parallel. This appears -- to be a Cabal library bug. Original issue: -- https://github.com/fpco/stack/issues/84. Ideally we'd be able to remove -- this. , eeConfigureLock = configLock , eeInstallLock = installLock , eeBaseConfigOpts = baseConfigOpts , eeGhcPkgIds = idMap , eeTempDir = tmpdir , eeSetupHs = setupHs , eeSetupShimHs = setupShimHs , eeSetupExe = setupExe , eeCabalPkgVer = cabalPkgVer , eeTotalWanted = totalWanted , eeWanted = wantedLocalPackages locals , eeLocals = locals , eeGlobalDB = globalDB , eeGlobalDumpPkgs = toDumpPackagesByGhcPkgId globalPackages , eeSnapshotDumpPkgs = snapshotPackagesTVar , eeLocalDumpPkgs = localPackagesTVar , eeLogFiles = logFilesTChan , eeGetGhcPath = runRIO env getGhcPath , eeGetGhcjsPath = runRIO env getGhcjsPath , eeCustomBuilt = customBuiltRef } `finally` dumpLogs logFilesTChan totalWanted where toDumpPackagesByGhcPkgId = Map.fromList . map (\dp -> (dpGhcPkgId dp, dp)) createTempDirFunction | Just True <- boptsKeepTmpFiles bopts = withKeepSystemTempDir | otherwise = withSystemTempDir dumpLogs :: TChan (Path Abs Dir, Path Abs File) -> Int -> RIO env () dumpLogs chan totalWanted = do allLogs <- fmap reverse $ liftIO $ atomically drainChan case allLogs of -- No log files generated, nothing to dump [] -> return () firstLog:_ -> do toDump <- view $ configL.to configDumpLogs case toDump of DumpAllLogs -> mapM_ (dumpLog "") allLogs DumpWarningLogs -> mapM_ dumpLogIfWarning allLogs DumpNoLogs | totalWanted > 1 -> logInfo $ "Build output has been captured to log files, use " <> "--dump-logs to see it on the console" | otherwise -> return () logInfo $ "Log files have been written to: " <> fromString (toFilePath (parent (snd firstLog))) -- We only strip the colors /after/ we've dumped logs, so that -- we get pretty colors in our dump output on the terminal. colors <- shouldForceGhcColorFlag when colors $ liftIO $ mapM_ (stripColors . snd) allLogs where drainChan :: STM [(Path Abs Dir, Path Abs File)] drainChan = do mx <- tryReadTChan chan case mx of Nothing -> return [] Just x -> do xs <- drainChan return $ x:xs dumpLogIfWarning :: (Path Abs Dir, Path Abs File) -> RIO env () dumpLogIfWarning (pkgDir, filepath) = do firstWarning <- withSourceFile (toFilePath filepath) $ \src -> runConduit $ src .| CT.decodeUtf8Lenient .| CT.lines .| CL.map stripCR .| CL.filter isWarning .| CL.take 1 unless (null firstWarning) $ dumpLog " due to warnings" (pkgDir, filepath) isWarning :: Text -> Bool isWarning t = ": Warning:" `T.isSuffixOf` t -- prior to GHC 8 || ": warning:" `T.isInfixOf` t -- GHC 8 is slightly different dumpLog :: String -> (Path Abs Dir, Path Abs File) -> RIO env () dumpLog msgSuffix (pkgDir, filepath) = do logInfo $ "\n-- Dumping log file" <> fromString msgSuffix <> ": " <> fromString (toFilePath filepath) <> "\n" compilerVer <- view actualCompilerVersionL withSourceFile (toFilePath filepath) $ \src -> runConduit $ src .| CT.decodeUtf8Lenient .| mungeBuildOutput ExcludeTHLoading ConvertPathsToAbsolute pkgDir compilerVer .| CL.mapM_ (logInfo . RIO.display) logInfo $ "\n-- End of log file: " <> fromString (toFilePath filepath) <> "\n" stripColors :: Path Abs File -> IO () stripColors fp = do let colorfp = toFilePath fp ++ "-color" withSourceFile (toFilePath fp) $ \src -> withSinkFile colorfp $ \sink -> runConduit $ src .| sink withSourceFile colorfp $ \src -> withSinkFile (toFilePath fp) $ \sink -> runConduit $ src .| noColors .| sink where noColors = do CB.takeWhile (/= 27) -- ESC mnext <- CB.head case mnext of Nothing -> return () Just x -> assert (x == 27) $ do -- Color sequences always end with an m CB.dropWhile (/= 109) -- m CB.drop 1 -- drop the m itself noColors -- | Perform the actual plan executePlan :: HasEnvConfig env => BuildOptsCLI -> BaseConfigOpts -> [LocalPackage] -> [DumpPackage () () ()] -- ^ global packages -> [DumpPackage () () ()] -- ^ snapshot packages -> [DumpPackage () () ()] -- ^ local packages -> InstalledMap -> Map PackageName Target -> Plan -> RIO env () executePlan boptsCli baseConfigOpts locals globalPackages snapshotPackages localPackages installedMap targets plan = do logDebug "Executing the build plan" bopts <- view buildOptsL withExecuteEnv bopts boptsCli baseConfigOpts locals globalPackages snapshotPackages localPackages (executePlan' installedMap targets plan) copyExecutables (planInstallExes plan) config <- view configL menv' <- liftIO $ configProcessContextSettings config EnvSettings { esIncludeLocals = True , esIncludeGhcPackagePath = True , esStackExe = True , esLocaleUtf8 = False , esKeepGhcRts = False } withProcessContext menv' $ forM_ (boptsCLIExec boptsCli) $ \(cmd, args) -> proc cmd args runProcess_ copyExecutables :: HasEnvConfig env => Map Text InstallLocation -> RIO env () copyExecutables exes | Map.null exes = return () copyExecutables exes = do snapBin <- ( bindirSuffix) `liftM` installationRootDeps localBin <- ( bindirSuffix) `liftM` installationRootLocal compilerSpecific <- boptsInstallCompilerTool <$> view buildOptsL destDir <- if compilerSpecific then bindirCompilerTools else view $ configL.to configLocalBin ensureDir destDir destDir' <- liftIO . D.canonicalizePath . toFilePath $ destDir platform <- view platformL let ext = case platform of Platform _ Windows -> ".exe" _ -> "" currExe <- liftIO getExecutablePath -- needed for windows, see below installed <- forMaybeM (Map.toList exes) $ \(name, loc) -> do let bindir = case loc of Snap -> snapBin Local -> localBin mfp <- liftIO $ forgivingAbsence (resolveFile bindir $ T.unpack name ++ ext) >>= rejectMissingFile case mfp of Nothing -> do logWarn $ "Couldn't find executable " <> RIO.display name <> " in directory " <> fromString (toFilePath bindir) return Nothing Just file -> do let destFile = destDir' FP. T.unpack name ++ ext logInfo $ "Copying from " <> fromString (toFilePath file) <> " to " <> fromString destFile liftIO $ case platform of Platform _ Windows | FP.equalFilePath destFile currExe -> windowsRenameCopy (toFilePath file) destFile _ -> D.copyFile (toFilePath file) destFile return $ Just (name <> T.pack ext) unless (null installed) $ do logInfo "" logInfo $ "Copied executables to " <> fromString destDir' <> ":" forM_ installed $ \exe -> logInfo ("- " <> RIO.display exe) unless compilerSpecific $ warnInstallSearchPathIssues destDir' installed -- | Windows can't write over the current executable. Instead, we rename the -- current executable to something else and then do the copy. windowsRenameCopy :: FilePath -> FilePath -> IO () windowsRenameCopy src dest = do D.copyFile src new D.renameFile dest old D.renameFile new dest where new = dest ++ ".new" old = dest ++ ".old" -- | Perform the actual plan (internal) executePlan' :: HasEnvConfig env => InstalledMap -> Map PackageName Target -> Plan -> ExecuteEnv -> RIO env () executePlan' installedMap0 targets plan ee@ExecuteEnv {..} = do when (toCoverage $ boptsTestOpts eeBuildOpts) deleteHpcReports cv <- view actualCompilerVersionL let wc = view whichCompilerL cv case Map.toList $ planUnregisterLocal plan of [] -> return () ids -> do localDB <- packageDatabaseLocal forM_ ids $ \(id', (ident, reason)) -> do logInfo $ RIO.display ident <> ": unregistering" <> if T.null reason then "" else " (" <> RIO.display reason <> ")" unregisterGhcPkgId wc cv localDB id' ident liftIO $ atomically $ modifyTVar' eeLocalDumpPkgs $ \initMap -> foldl' (flip Map.delete) initMap $ Map.keys (planUnregisterLocal plan) run <- askRunInIO -- If running tests concurrently with eachother, then create an MVar -- which is empty while each test is being run. concurrentTests <- view $ configL.to configConcurrentTests mtestLock <- if concurrentTests then return Nothing else Just <$> liftIO (newMVar ()) let actions = concatMap (toActions installedMap' mtestLock run ee) $ Map.elems $ Map.mergeWithKey (\_ b f -> Just (Just b, Just f)) (fmap (\b -> (Just b, Nothing))) (fmap (\f -> (Nothing, Just f))) (planTasks plan) (planFinals plan) threads <- view $ configL.to configJobs let keepGoing = fromMaybe (not (M.null (planFinals plan))) (boptsKeepGoing eeBuildOpts) terminal <- view terminalL errs <- liftIO $ runActions threads keepGoing actions $ \doneVar actionsVar -> do let total = length actions loop prev | prev == total = run $ logStickyDone ("Completed " <> RIO.display total <> " action(s).") | otherwise = do inProgress <- readTVarIO actionsVar let packageNames = map (\(ActionId pkgID _) -> packageIdentifierText pkgID) (toList inProgress) nowBuilding [] = "" nowBuilding names = mconcat $ ": " : intersperse ", " (map RIO.display names) when terminal $ run $ logSticky $ "Progress " <> RIO.display prev <> "/" <> RIO.display total <> nowBuilding packageNames done <- atomically $ do done <- readTVar doneVar check $ done /= prev return done loop done when (total > 1) $ loop 0 when (toCoverage $ boptsTestOpts eeBuildOpts) $ do generateHpcUnifiedReport generateHpcMarkupIndex unless (null errs) $ throwM $ ExecutionFailure errs when (boptsHaddock eeBuildOpts) $ do snapshotDumpPkgs <- liftIO (readTVarIO eeSnapshotDumpPkgs) localDumpPkgs <- liftIO (readTVarIO eeLocalDumpPkgs) generateLocalHaddockIndex wc eeBaseConfigOpts localDumpPkgs eeLocals generateDepsHaddockIndex wc eeBaseConfigOpts eeGlobalDumpPkgs snapshotDumpPkgs localDumpPkgs eeLocals generateSnapHaddockIndex wc eeBaseConfigOpts eeGlobalDumpPkgs snapshotDumpPkgs when (boptsOpenHaddocks eeBuildOpts) $ do let planPkgs, localPkgs, installedPkgs, availablePkgs :: Map PackageName (PackageIdentifier, InstallLocation) planPkgs = Map.map (taskProvides &&& taskLocation) (planTasks plan) localPkgs = Map.fromList [(packageName p, (packageIdentifier p, Local)) | p <- map lpPackage eeLocals] installedPkgs = Map.map (swap . second installedPackageIdentifier) installedMap' availablePkgs = Map.unions [planPkgs, localPkgs, installedPkgs] openHaddocksInBrowser eeBaseConfigOpts availablePkgs (Map.keysSet targets) where installedMap' = Map.difference installedMap0 $ Map.fromList $ map (\(ident, _) -> (packageIdentifierName ident, ())) $ Map.elems $ planUnregisterLocal plan toActions :: HasEnvConfig env => InstalledMap -> Maybe (MVar ()) -> (RIO env () -> IO ()) -> ExecuteEnv -> (Maybe Task, Maybe Task) -- build and final -> [Action] toActions installedMap mtestLock runInBase ee (mbuild, mfinal) = abuild ++ afinal where abuild = case mbuild of Nothing -> [] Just task@Task {..} -> [ Action { actionId = ActionId taskProvides ATBuild , actionDeps = Set.map (\ident -> ActionId ident ATBuild) (tcoMissing taskConfigOpts) , actionDo = \ac -> runInBase $ singleBuild ac ee task installedMap False , actionConcurrency = ConcurrencyAllowed } ] afinal = case mfinal of Nothing -> [] Just task@Task {..} -> (if taskAllInOne then id else (:) Action { actionId = ActionId taskProvides ATBuildFinal , actionDeps = addBuild (Set.map (\ident -> ActionId ident ATBuild) (tcoMissing taskConfigOpts)) , actionDo = \ac -> runInBase $ singleBuild ac ee task installedMap True , actionConcurrency = ConcurrencyAllowed }) $ -- These are the "final" actions - running tests and benchmarks. (if Set.null tests then id else (:) Action { actionId = ActionId taskProvides ATRunTests , actionDeps = finalDeps , actionDo = \ac -> withLock mtestLock $ runInBase $ do singleTest topts (Set.toList tests) ac ee task installedMap -- Always allow tests tasks to run concurrently with -- other tasks, particularly build tasks. Note that -- 'mtestLock' can optionally make it so that only -- one test is run at a time. , actionConcurrency = ConcurrencyAllowed }) $ (if Set.null benches then id else (:) Action { actionId = ActionId taskProvides ATRunBenchmarks , actionDeps = finalDeps , actionDo = \ac -> runInBase $ do singleBench beopts (Set.toList benches) ac ee task installedMap -- Never run benchmarks concurrently with any other task, see #3663 , actionConcurrency = ConcurrencyDisallowed }) [] where comps = taskComponents task tests = testComponents comps benches = benchComponents comps finalDeps = if taskAllInOne then addBuild mempty else Set.singleton (ActionId taskProvides ATBuildFinal) addBuild = case mbuild of Nothing -> id Just _ -> Set.insert $ ActionId taskProvides ATBuild withLock Nothing f = f withLock (Just lock) f = withMVar lock $ \() -> f bopts = eeBuildOpts ee topts = boptsTestOpts bopts beopts = boptsBenchmarkOpts bopts -- | Generate the ConfigCache getConfigCache :: HasEnvConfig env => ExecuteEnv -> Task -> InstalledMap -> Bool -> Bool -> RIO env (Map PackageIdentifier GhcPkgId, ConfigCache) getConfigCache ExecuteEnv {..} task@Task {..} installedMap enableTest enableBench = do useExactConf <- view $ configL.to configAllowNewer let extra = -- We enable tests if the test suite dependencies are already -- installed, so that we avoid unnecessary recompilation based on -- cabal_macros.h changes when switching between 'stack build' and -- 'stack test'. See: -- https://github.com/commercialhaskell/stack/issues/805 case taskType of TTFiles lp _ -> -- FIXME: make this work with exact-configuration. -- Not sure how to plumb the info atm. See -- https://github.com/commercialhaskell/stack/issues/2049 [ "--enable-tests" | enableTest || (not useExactConf && depsPresent installedMap (lpTestDeps lp))] ++ [ "--enable-benchmarks" | enableBench || (not useExactConf && depsPresent installedMap (lpBenchDeps lp))] _ -> [] idMap <- liftIO $ readTVarIO eeGhcPkgIds let getMissing ident = case Map.lookup ident idMap of Nothing -- Expect to instead find it in installedMap if it's -- an initialBuildSteps target. | boptsCLIInitialBuildSteps eeBuildOptsCLI && taskIsTarget task, Just (_, installed) <- Map.lookup (packageIdentifierName ident) installedMap -> installedToGhcPkgId ident installed Just installed -> installedToGhcPkgId ident installed _ -> error "singleBuild: invariant violated, missing package ID missing" installedToGhcPkgId ident (Library ident' x _) = assert (ident == ident') $ Just (ident, x) installedToGhcPkgId _ (Executable _) = Nothing missing' = Map.fromList $ mapMaybe getMissing $ Set.toList missing TaskConfigOpts missing mkOpts = taskConfigOpts opts = mkOpts missing' allDeps = Set.fromList $ Map.elems missing' ++ Map.elems taskPresent cache = ConfigCache { configCacheOpts = opts { coNoDirs = coNoDirs opts ++ map T.unpack extra } , configCacheDeps = allDeps , configCacheComponents = case taskType of TTFiles lp _ -> Set.map (encodeUtf8 . renderComponent) $ lpComponents lp TTIndex{} -> Set.empty , configCacheHaddock = shouldHaddockPackage eeBuildOpts eeWanted (packageIdentifierName taskProvides) , configCachePkgSrc = taskCachePkgSrc } allDepsMap = Map.union missing' taskPresent return (allDepsMap, cache) -- | Ensure that the configuration for the package matches what is given ensureConfig :: HasEnvConfig env => ConfigCache -- ^ newConfigCache -> Path Abs Dir -- ^ package directory -> ExecuteEnv -> RIO env () -- ^ announce -> (ExcludeTHLoading -> [String] -> RIO env ()) -- ^ cabal -> Path Abs File -- ^ .cabal file -> Task -> RIO env Bool ensureConfig newConfigCache pkgDir ExecuteEnv {..} announce cabal cabalfp task = do newCabalMod <- liftIO (fmap modTime (D.getModificationTime (toFilePath cabalfp))) needConfig <- if boptsReconfigure eeBuildOpts || taskAnyMissing task then return True else do -- We can ignore the components portion of the config -- cache, because it's just used to inform 'construct -- plan that we need to plan to build additional -- components. These components don't affect the actual -- package configuration. let ignoreComponents cc = cc { configCacheComponents = Set.empty } -- Determine the old and new configuration in the local directory, to -- determine if we need to reconfigure. mOldConfigCache <- tryGetConfigCache pkgDir mOldCabalMod <- tryGetCabalMod pkgDir return $ fmap ignoreComponents mOldConfigCache /= Just (ignoreComponents newConfigCache) || mOldCabalMod /= Just newCabalMod let ConfigureOpts dirs nodirs = configCacheOpts newConfigCache when (taskBuildTypeConfig task) ensureConfigureScript when needConfig $ withMVar eeConfigureLock $ \_ -> do deleteCaches pkgDir announce let programNames = if eeCabalPkgVer < $(mkVersion "1.22") then ["ghc", "ghc-pkg"] else ["ghc", "ghc-pkg", "ghcjs", "ghcjs-pkg"] exes <- forM programNames $ \name -> do mpath <- findExecutable name return $ case mpath of Left _ -> [] Right x -> return $ concat ["--with-", name, "=", x] -- Configure cabal with arguments determined by -- Stack.Types.Build.configureOpts cabal KeepTHLoading $ "configure" : concat [ concat exes , dirs , nodirs ] writeConfigCache pkgDir newConfigCache writeCabalMod pkgDir newCabalMod return needConfig where -- When build-type is Configure, we need to have a configure -- script in the local directory. If it doesn't exist, build it -- with autoreconf -i. See: -- https://github.com/commercialhaskell/stack/issues/3534 ensureConfigureScript = do let fp = pkgDir $(mkRelFile "configure") exists <- doesFileExist fp unless exists $ do logInfo $ "Trying to generate configure with autoreconf in " <> fromString (toFilePath pkgDir) withWorkingDir (toFilePath pkgDir) $ readProcessNull "autoreconf" ["-i"] `catchAny` \ex -> logWarn $ "Unable to run autoreconf: " <> displayShow ex announceTask :: HasLogFunc env => Task -> Text -> RIO env () announceTask task x = logInfo $ RIO.display (taskProvides task) <> ": " <> RIO.display x -- | How we deal with output from GHC, either dumping to a log file or the -- console (with some prefix). data OutputType = OTLogFile !(Path Abs File) !Handle | OTConsole !Utf8Builder -- | This sets up a context for executing build steps which need to run -- Cabal (via a compiled Setup.hs). In particular it does the following: -- -- * Ensures the package exists in the file system, downloading if necessary. -- -- * Opens a log file if the built output shouldn't go to stderr. -- -- * Ensures that either a simple Setup.hs is built, or the package's -- custom setup is built. -- -- * Provides the user a function with which run the Cabal process. withSingleContext :: forall env a. HasEnvConfig env => ActionContext -> ExecuteEnv -> Task -> Maybe (Map PackageIdentifier GhcPkgId) -- ^ All dependencies' package ids to provide to Setup.hs. If -- Nothing, just provide global and snapshot package -- databases. -> Maybe String -> ( Package -- Package info -> Path Abs File -- Cabal file path -> Path Abs Dir -- Package root directory file path -> (ExcludeTHLoading -> [String] -> RIO env ()) -- Function to run Cabal with args -> (Text -> RIO env ()) -- An 'announce' function, for different build phases -> OutputType -> RIO env a) -> RIO env a withSingleContext ActionContext {..} ExecuteEnv {..} task@Task {..} mdeps msuffix inner0 = withPackage $ \package cabalfp pkgDir -> withOutputType pkgDir package $ \outputType -> withCabal package pkgDir outputType $ \cabal -> inner0 package cabalfp pkgDir cabal announce outputType where announce = announceTask task wanted = case taskType of TTFiles lp _ -> lpWanted lp TTIndex{} -> False -- Output to the console if this is the last task, and the user -- asked to build it specifically. When the action is a -- 'ConcurrencyDisallowed' action (benchmarks), then we can also be -- sure to have excluse access to the console, so output is also -- sent to the console in this case. -- -- See the discussion on #426 for thoughts on sending output to the -- console from concurrent tasks. console = (wanted && all (\(ActionId ident _) -> ident == taskProvides) (Set.toList acRemaining) && eeTotalWanted == 1 ) || (acConcurrency == ConcurrencyDisallowed) withPackage inner = case taskType of TTFiles lp _ -> inner (lpPackage lp) (lpCabalFile lp) (lpDir lp) TTIndex package _ pir -> do mdist <- distRelativeDir dir <- unpackPackageIdent eeTempDir mdist pir let name = packageIdentifierName taskProvides cabalfpRel <- parseRelFile $ packageNameString name ++ ".cabal" let cabalfp = dir cabalfpRel inner package cabalfp dir withOutputType pkgDir package inner -- If the user requested interleaved output, dump to the console with a -- prefix. | boptsInterleavedOutput eeBuildOpts = inner $ OTConsole $ RIO.display (packageName package) <> "> " -- Not in interleaved mode. When building a single wanted package, dump -- to the console with no prefix. | console = inner $ OTConsole mempty -- Neither condition applies, dump to a file. | otherwise = do logPath <- buildLogPath package msuffix ensureDir (parent logPath) let fp = toFilePath logPath -- We only want to dump logs for local non-dependency packages case taskType of TTFiles lp _ | lpWanted lp -> liftIO $ atomically $ writeTChan eeLogFiles (pkgDir, logPath) _ -> return () withBinaryFile fp WriteMode $ \h -> inner $ OTLogFile logPath h withCabal :: Package -> Path Abs Dir -> OutputType -> ((ExcludeTHLoading -> [String] -> RIO env ()) -> RIO env a) -> RIO env a withCabal package pkgDir outputType inner = do config <- view configL unless (configAllowDifferentUser config) $ checkOwnership (pkgDir configWorkDir config) let envSettings = EnvSettings { esIncludeLocals = taskLocation task == Local , esIncludeGhcPackagePath = False , esStackExe = False , esLocaleUtf8 = True , esKeepGhcRts = False } menv <- liftIO $ configProcessContextSettings config envSettings distRelativeDir' <- distRelativeDir esetupexehs <- -- Avoid broken Setup.hs files causing problems for simple build -- types, see: -- https://github.com/commercialhaskell/stack/issues/370 case (packageBuildType package, eeSetupExe) of (C.Simple, Just setupExe) -> return $ Left setupExe _ -> liftIO $ Right <$> getSetupHs pkgDir inner $ \stripTHLoading args -> do let cabalPackageArg -- Omit cabal package dependency when building -- Cabal. See -- https://github.com/commercialhaskell/stack/issues/1356 | packageName package == $(mkPackageName "Cabal") = [] | otherwise = ["-package=" ++ packageIdentifierString (PackageIdentifier cabalPackageName eeCabalPkgVer)] packageDBArgs = ( "-clear-package-db" : "-global-package-db" : map (("-package-db=" ++) . toFilePathNoTrailingSep) (bcoExtraDBs eeBaseConfigOpts) ) ++ ( ("-package-db=" ++ toFilePathNoTrailingSep (bcoSnapDB eeBaseConfigOpts)) : ("-package-db=" ++ toFilePathNoTrailingSep (bcoLocalDB eeBaseConfigOpts)) : ["-hide-all-packages"] ) warnCustomNoDeps :: RIO env () warnCustomNoDeps = case (taskType, packageBuildType package) of (TTFiles lp Local, C.Custom) | lpWanted lp -> do prettyWarnL [ flow "Package" , display $ packageName package , flow "uses a custom Cabal build, but does not use a custom-setup stanza" ] _ -> return () getPackageArgs :: Path Abs Dir -> RIO env [String] getPackageArgs setupDir = case (packageSetupDeps package, mdeps) of -- The package is using the Cabal custom-setup -- configuration introduced in Cabal 1.24. In -- this case, the package is providing an -- explicit list of dependencies, and we -- should simply use all of them. (Just customSetupDeps, _) -> do unless (Map.member $(mkPackageName "Cabal") customSetupDeps) $ prettyWarnL [ display $ packageName package , "has a setup-depends field, but it does not mention a Cabal dependency. This is likely to cause build errors." ] allDeps <- case mdeps of Just x -> return x Nothing -> do prettyWarnS "In getPackageArgs: custom-setup in use, but no dependency map present" return Map.empty matchedDeps <- forM (Map.toList customSetupDeps) $ \(name, range) -> do let matches (PackageIdentifier name' version) = name == name' && version `withinRange` range case filter (matches . fst) (Map.toList allDeps) of x:xs -> do unless (null xs) (logWarn ("Found multiple installed packages for custom-setup dep: " <> RIO.display name)) return ("-package-id=" ++ ghcPkgIdString (snd x), Just (toCabalPackageIdentifier (fst x))) [] -> do logWarn ("Could not find custom-setup dep: " <> RIO.display name) return ("-package=" ++ packageNameString name, Nothing) let depsArgs = map fst matchedDeps -- Generate setup_macros.h and provide it to ghc let macroDeps = mapMaybe snd matchedDeps cppMacrosFile = toFilePath $ setupDir $(mkRelFile "setup_macros.h") cppArgs = ["-optP-include", "-optP" ++ cppMacrosFile] liftIO $ S.writeFile cppMacrosFile (encodeUtf8 (T.pack (C.generatePackageVersionMacros macroDeps))) return (packageDBArgs ++ depsArgs ++ cppArgs) -- This branch is taken when -- 'explicit-setup-deps' is requested in your -- stack.yaml file. (Nothing, Just deps) | explicitSetupDeps (packageName package) config -> do warnCustomNoDeps -- Stack always builds with the global Cabal for various -- reproducibility issues. let depsMinusCabal = map ghcPkgIdString $ Set.toList $ addGlobalPackages deps (Map.elems eeGlobalDumpPkgs) return ( packageDBArgs ++ cabalPackageArg ++ map ("-package-id=" ++) depsMinusCabal) -- This branch is usually taken for builds, and -- is always taken for `stack sdist`. -- -- This approach is debatable. It adds access to the -- snapshot package database for Cabal. There are two -- possible objections: -- -- 1. This doesn't isolate the build enough; arbitrary -- other packages available could cause the build to -- succeed or fail. -- -- 2. This doesn't provide enough packages: we should also -- include the local database when building local packages. -- -- Currently, this branch is only taken via `stack -- sdist` or when explicitly requested in the -- stack.yaml file. (Nothing, _) -> do warnCustomNoDeps return $ cabalPackageArg ++ -- NOTE: This is different from -- packageDBArgs above in that it does not -- include the local database and does not -- pass in the -hide-all-packages argument ("-clear-package-db" : "-global-package-db" : map (("-package-db=" ++) . toFilePathNoTrailingSep) (bcoExtraDBs eeBaseConfigOpts) ++ ["-package-db=" ++ toFilePathNoTrailingSep (bcoSnapDB eeBaseConfigOpts)]) setupArgs = ("--builddir=" ++ toFilePathNoTrailingSep distRelativeDir') : args runExe :: Path Abs File -> [String] -> RIO env () runExe exeName fullArgs = do compilerVer <- view actualCompilerVersionL runAndOutput compilerVer `catch` \ece -> do (mlogFile, bss) <- case outputType of OTConsole _ -> return (Nothing, []) OTLogFile logFile h -> do liftIO $ hClose h fmap (Just logFile,) $ withSourceFile (toFilePath logFile) $ \src -> runConduit $ src .| CT.decodeUtf8Lenient .| mungeBuildOutput stripTHLoading makeAbsolute pkgDir compilerVer .| CL.consume throwM $ CabalExitedUnsuccessfully (eceExitCode ece) taskProvides exeName fullArgs mlogFile bss where runAndOutput :: CompilerVersion 'CVActual -> RIO env () runAndOutput compilerVer = withWorkingDir (toFilePath pkgDir) $ withProcessContext menv $ case outputType of OTLogFile _ h -> proc (toFilePath exeName) fullArgs $ runProcess_ . setStdin (byteStringInput "") . setStdout (useHandleOpen h) . setStderr (useHandleOpen h) OTConsole prefix -> void $ sinkProcessStderrStdout (toFilePath exeName) fullArgs (outputSink KeepTHLoading LevelWarn compilerVer prefix) (outputSink stripTHLoading LevelInfo compilerVer prefix) outputSink :: HasCallStack => ExcludeTHLoading -> LogLevel -> CompilerVersion 'CVActual -> Utf8Builder -> ConduitM S.ByteString Void (RIO env) () outputSink excludeTH level compilerVer prefix = CT.decodeUtf8Lenient .| mungeBuildOutput excludeTH makeAbsolute pkgDir compilerVer .| CL.mapM_ (logGeneric "" level . (prefix <>) . RIO.display) -- If users want control, we should add a config option for this makeAbsolute :: ConvertPathsToAbsolute makeAbsolute = case stripTHLoading of ExcludeTHLoading -> ConvertPathsToAbsolute KeepTHLoading -> KeepPathsAsIs exeName <- case esetupexehs of Left setupExe -> return setupExe Right setuphs -> do distDir <- distDirFromDir pkgDir let setupDir = distDir $(mkRelDir "setup") outputFile = setupDir $(mkRelFile "setup") customBuilt <- liftIO $ readIORef eeCustomBuilt if Set.member (packageName package) customBuilt then return outputFile else do ensureDir setupDir compiler <- view $ actualCompilerVersionL.whichCompilerL compilerPath <- case compiler of Ghc -> eeGetGhcPath Ghcjs -> eeGetGhcjsPath packageArgs <- getPackageArgs setupDir runExe compilerPath $ [ "--make" , "-odir", toFilePathNoTrailingSep setupDir , "-hidir", toFilePathNoTrailingSep setupDir , "-i", "-i." ] ++ packageArgs ++ [ toFilePath setuphs , toFilePath eeSetupShimHs , "-main-is" , "StackSetupShim.mainOverride" , "-o", toFilePath outputFile , "-threaded" ] ++ (case compiler of Ghc -> [] Ghcjs -> ["-build-runner"]) liftIO $ atomicModifyIORef' eeCustomBuilt $ \oldCustomBuilt -> (Set.insert (packageName package) oldCustomBuilt, ()) return outputFile runExe exeName $ (if boptsCabalVerbose eeBuildOpts then ("--verbose":) else id) setupArgs -- Implements running a package's build, used to implement 'ATBuild' and -- 'ATBuildFinal' tasks. In particular this does the following: -- -- * Checks if the package exists in the precompiled cache, and if so, -- add it to the database instead of performing the build. -- -- * Runs the configure step if needed ('ensureConfig') -- -- * Runs the build step -- -- * Generates haddocks -- -- * Registers the library and copiesthe built executables into the -- local install directory. Note that this is literally invoking Cabal -- with @copy@, and not the copying done by @stack install@ - that is -- handled by 'copyExecutables'. singleBuild :: forall env. (HasEnvConfig env, HasRunner env) => ActionContext -> ExecuteEnv -> Task -> InstalledMap -> Bool -- ^ Is this a final build? -> RIO env () singleBuild ac@ActionContext {..} ee@ExecuteEnv {..} task@Task {..} installedMap isFinalBuild = do (allDepsMap, cache) <- getConfigCache ee task installedMap enableTests enableBenchmarks mprecompiled <- getPrecompiled cache minstalled <- case mprecompiled of Just precompiled -> copyPreCompiled precompiled Nothing -> realConfigAndBuild cache allDepsMap case minstalled of Nothing -> return () Just installed -> do writeFlagCache installed cache liftIO $ atomically $ modifyTVar eeGhcPkgIds $ Map.insert taskProvides installed where pname = packageIdentifierName taskProvides shouldHaddockPackage' = shouldHaddockPackage eeBuildOpts eeWanted pname doHaddock package = shouldHaddockPackage' && not isFinalBuild && -- Works around haddock failing on bytestring-builder since it has no modules -- when bytestring is new enough. packageHasExposedModules package buildingFinals = isFinalBuild || taskAllInOne enableTests = buildingFinals && any isCTest (taskComponents task) enableBenchmarks = buildingFinals && any isCBench (taskComponents task) annSuffix executableBuildStatuses = if result == "" then "" else " (" <> result <> ")" where result = T.intercalate " + " $ concat [ ["lib" | taskAllInOne && hasLib] , ["internal-lib" | taskAllInOne && hasSubLib] , ["exe" | taskAllInOne && hasExe] , ["test" | enableTests] , ["bench" | enableBenchmarks] ] (hasLib, hasSubLib, hasExe) = case taskType of TTFiles lp Local -> let package = lpPackage lp hasLibrary = case packageLibraries package of NoLibraries -> False HasLibraries _ -> True hasSubLibrary = not . Set.null $ packageInternalLibraries package hasExecutables = not . Set.null $ exesToBuild executableBuildStatuses lp in (hasLibrary, hasSubLibrary, hasExecutables) -- This isn't true, but we don't want to have this info for -- upstream deps. _ -> (False, False, False) getPrecompiled cache = case taskLocation task of Snap | not shouldHaddockPackage' -> do mpc <- case taskLocation task of Snap -> readPrecompiledCache (ttPackageLocation taskType) (configCacheOpts cache) (configCacheDeps cache) _ -> return Nothing case mpc of Nothing -> return Nothing -- Only pay attention to precompiled caches that refer to packages within -- the snapshot. Just pc | maybe False (bcoSnapInstallRoot eeBaseConfigOpts `isProperPrefixOf`) (parseAbsFile =<< pcLibrary pc) -> return Nothing -- If old precompiled cache files are left around but snapshots are deleted, -- it is possible for the precompiled file to refer to the very library -- we're building, and if flags are changed it may try to copy the library -- to itself. This check prevents that from happening. Just pc -> do let allM _ [] = return True allM f (x:xs) = do b <- f x if b then allM f xs else return False b <- liftIO $ allM D.doesFileExist $ maybe id (:) (pcLibrary pc) $ pcExes pc return $ if b then Just pc else Nothing _ -> return Nothing copyPreCompiled (PrecompiledCache mlib sublibs exes) = do wc <- view $ actualCompilerVersionL.whichCompilerL announceTask task "using precompiled package" -- We need to copy .conf files for the main library and all sublibraries which exist in the cache, -- from their old snapshot to the new one. However, we must unregister any such library in the new -- snapshot, in case it was built with different flags. let subLibNames = map T.unpack . Set.toList $ case taskType of TTFiles lp _ -> packageInternalLibraries $ lpPackage lp TTIndex p _ _ -> packageInternalLibraries p (name, version) = toTuple taskProvides mainLibName = packageNameString name mainLibVersion = versionString version pkgName = mainLibName ++ "-" ++ mainLibVersion -- z-package-z-internal for internal lib internal of package package toCabalInternalLibName n = concat ["z-", mainLibName, "-z-", n, "-", mainLibVersion] allToUnregister = map (const pkgName) (maybeToList mlib) ++ map toCabalInternalLibName subLibNames allToRegister = maybeToList mlib ++ sublibs unless (null allToRegister) $ do withMVar eeInstallLock $ \() -> do -- We want to ignore the global and user databases. -- Unfortunately, ghc-pkg doesn't take such arguments on the -- command line. Instead, we'll set GHC_PACKAGE_PATH. See: -- https://github.com/commercialhaskell/stack/issues/1146 let modifyEnv = Map.insert (ghcPkgPathEnvVar wc) (T.pack $ toFilePathNoTrailingSep $ bcoSnapDB eeBaseConfigOpts) withModifyEnvVars modifyEnv $ do let ghcPkgExe = ghcPkgExeName wc -- first unregister everything that needs to be unregistered forM_ allToUnregister $ \packageName -> catchAny (readProcessNull ghcPkgExe [ "unregister", "--force", packageName]) (const (return ())) -- now, register the cached conf files forM_ allToRegister $ \libpath -> proc ghcPkgExe [ "register", "--force", libpath] readProcess_ liftIO $ forM_ exes $ \exe -> do D.createDirectoryIfMissing True bindir let dst = bindir FP. FP.takeFileName exe createLink exe dst `catchIO` \_ -> D.copyFile exe dst case (mlib, exes) of (Nothing, _:_) -> markExeInstalled (taskLocation task) taskProvides _ -> return () -- Find the package in the database let pkgDbs = [bcoSnapDB eeBaseConfigOpts] case mlib of Nothing -> return $ Just $ Executable taskProvides Just _ -> do mpkgid <- loadInstalledPkg wc pkgDbs eeSnapshotDumpPkgs pname return $ Just $ case mpkgid of Nothing -> assert False $ Executable taskProvides Just pkgid -> Library taskProvides pkgid Nothing where bindir = toFilePath $ bcoSnapInstallRoot eeBaseConfigOpts bindirSuffix realConfigAndBuild cache allDepsMap = withSingleContext ac ee task (Just allDepsMap) Nothing $ \package cabalfp pkgDir cabal announce _outputType -> do executableBuildStatuses <- getExecutableBuildStatuses package pkgDir when (not (cabalIsSatisfied executableBuildStatuses) && taskIsTarget task) (logInfo ("Building all executables for `" <> RIO.display (packageName package) <> "' once. After a successful build of all of them, only specified executables will be rebuilt.")) _neededConfig <- ensureConfig cache pkgDir ee (announce ("configure" <> annSuffix executableBuildStatuses)) cabal cabalfp task let installedMapHasThisPkg :: Bool installedMapHasThisPkg = case Map.lookup (packageName package) installedMap of Just (_, Library ident _ _) -> ident == taskProvides Just (_, Executable _) -> True _ -> False case ( boptsCLIOnlyConfigure eeBuildOptsCLI , boptsCLIInitialBuildSteps eeBuildOptsCLI && taskIsTarget task) of -- A full build is done if there are downstream actions, -- because their configure step will require that this -- package is built. See -- https://github.com/commercialhaskell/stack/issues/2787 (True, _) | null acDownstream -> return Nothing (_, True) | null acDownstream || installedMapHasThisPkg -> do initialBuildSteps executableBuildStatuses cabal announce return Nothing _ -> liftM Just $ realBuild cache package pkgDir cabal announce executableBuildStatuses initialBuildSteps executableBuildStatuses cabal announce = do () <- announce ("initial-build-steps" <> annSuffix executableBuildStatuses) cabal KeepTHLoading ["repl", "stack-initial-build-steps"] realBuild :: ConfigCache -> Package -> Path Abs Dir -> (ExcludeTHLoading -> [String] -> RIO env ()) -> (Text -> RIO env ()) -> Map Text ExecutableBuildStatus -> RIO env Installed realBuild cache package pkgDir cabal announce executableBuildStatuses = do wc <- view $ actualCompilerVersionL.whichCompilerL markExeNotInstalled (taskLocation task) taskProvides case taskType of TTFiles lp _ -> do -- FIXME should this only be for local packages? when enableTests $ unsetTestSuccess pkgDir mapM_ (uncurry (writeBuildCache pkgDir)) (Map.toList $ lpNewBuildCaches lp) TTIndex{} -> return () -- FIXME: only output these if they're in the build plan. preBuildTime <- modTime <$> liftIO getCurrentTime let postBuildCheck _succeeded = do mlocalWarnings <- case taskType of TTFiles lp Local -> do warnings <- checkForUnlistedFiles taskType preBuildTime pkgDir -- TODO: Perhaps only emit these warnings for non extra-dep? return (Just (lpCabalFile lp, warnings)) _ -> return Nothing -- NOTE: once -- https://github.com/commercialhaskell/stack/issues/2649 -- is resolved, we will want to partition the warnings -- based on variety, and output in different lists. let showModuleWarning (UnlistedModulesWarning comp modules) = "- In" <+> fromString (T.unpack (renderComponent comp)) <> ":" <> line <> indent 4 (mconcat $ intersperse line $ map (styleGood . fromString . C.display) modules) forM_ mlocalWarnings $ \(cabalfp, warnings) -> do unless (null warnings) $ prettyWarn $ "The following modules should be added to exposed-modules or other-modules in" <+> display cabalfp <> ":" <> line <> indent 4 (mconcat $ intersperse line $ map showModuleWarning warnings) <> line <> line <> "Missing modules in the cabal file are likely to cause undefined reference errors from the linker, along with other problems." () <- announce ("build" <> annSuffix executableBuildStatuses) config <- view configL extraOpts <- extraBuildOptions wc eeBuildOpts let stripTHLoading | configHideTHLoading config = ExcludeTHLoading | otherwise = KeepTHLoading cabal stripTHLoading (("build" :) $ (++ extraOpts) $ case (taskType, taskAllInOne, isFinalBuild) of (_, True, True) -> error "Invariant violated: cannot have an all-in-one build that also has a final build step." (TTFiles lp _, False, False) -> primaryComponentOptions executableBuildStatuses lp (TTFiles lp _, False, True) -> finalComponentOptions lp (TTFiles lp _, True, False) -> primaryComponentOptions executableBuildStatuses lp ++ finalComponentOptions lp (TTIndex{}, _, _) -> []) `catch` \ex -> case ex of CabalExitedUnsuccessfully{} -> postBuildCheck False >> throwM ex _ -> throwM ex postBuildCheck True when (doHaddock package) $ do announce "haddock" sourceFlag <- if not (boptsHaddockHyperlinkSource eeBuildOpts) then return [] else do -- See #2429 for why the temp dir is used ec <- withWorkingDir (toFilePath eeTempDir) $ proc "haddock" ["--hyperlinked-source"] $ \pc -> withProcess (setStdout createSource $ setStderr createSource pc) $ \p -> runConcurrently $ Concurrently (runConduit $ getStdout p .| CL.sinkNull) *> Concurrently (runConduit $ getStderr p .| CL.sinkNull) *> Concurrently (waitExitCode p) case ec of -- Fancy crosslinked source ExitSuccess -> return ["--haddock-option=--hyperlinked-source"] -- Older hscolour colouring ExitFailure _ -> do hscolourExists <- doesExecutableExist "HsColour" unless hscolourExists $ logWarn ("Warning: haddock not generating hyperlinked sources because 'HsColour' not\n" <> "found on PATH (use 'stack install hscolour' to install).") return ["--hyperlink-source" | hscolourExists] -- For GHC 8.4 and later, provide the --quickjump option. actualCompiler <- view actualCompilerVersionL let quickjump = case actualCompiler of GhcVersion ghcVer | ghcVer >= $(mkVersion "8.4") -> ["--haddock-option=--quickjump"] _ -> [] cabal KeepTHLoading $ concat [ ["haddock", "--html", "--hoogle", "--html-location=../$pkg-$version/"] , sourceFlag , ["--internal" | boptsHaddockInternal eeBuildOpts] , [ "--haddock-option=" <> opt | opt <- hoAdditionalArgs (boptsHaddockOpts eeBuildOpts) ] , quickjump ] let hasLibrary = case packageLibraries package of NoLibraries -> False HasLibraries _ -> True packageHasComponentSet f = not $ Set.null $ f package hasInternalLibrary = packageHasComponentSet packageInternalLibraries hasExecutables = packageHasComponentSet packageExes shouldCopy = not isFinalBuild && (hasLibrary || hasInternalLibrary || hasExecutables) when shouldCopy $ withMVar eeInstallLock $ \() -> do announce "copy/register" eres <- try $ cabal KeepTHLoading ["copy"] case eres of Left err@CabalExitedUnsuccessfully{} -> throwM $ CabalCopyFailed (packageBuildType package == C.Simple) (show err) _ -> return () when hasLibrary $ cabal KeepTHLoading ["register"] let (installedPkgDb, installedDumpPkgsTVar) = case taskLocation task of Snap -> ( bcoSnapDB eeBaseConfigOpts , eeSnapshotDumpPkgs ) Local -> ( bcoLocalDB eeBaseConfigOpts , eeLocalDumpPkgs ) let ident = PackageIdentifier (packageName package) (packageVersion package) -- only return the sublibs to cache them if we also cache the main lib (that is, if it exists) (mpkgid, sublibsPkgIds) <- case packageLibraries package of HasLibraries _ -> do sublibsPkgIds <- fmap catMaybes $ forM (Set.toList $ packageInternalLibraries package) $ \sublib -> do -- z-haddock-library-z-attoparsec for internal lib attoparsec of haddock-library let sublibName = T.concat ["z-", packageNameText $ packageName package, "-z-", sublib] case parsePackageName sublibName of Nothing -> return Nothing -- invalid lib, ignored Just subLibName -> loadInstalledPkg wc [installedPkgDb] installedDumpPkgsTVar subLibName mpkgid <- loadInstalledPkg wc [installedPkgDb] installedDumpPkgsTVar (packageName package) case mpkgid of Nothing -> throwM $ Couldn'tFindPkgId $ packageName package Just pkgid -> return (Library ident pkgid Nothing, sublibsPkgIds) NoLibraries -> do markExeInstalled (taskLocation task) taskProvides -- TODO unify somehow with writeFlagCache? return (Executable ident, []) -- don't return sublibs in this case case taskLocation task of Snap -> writePrecompiledCache eeBaseConfigOpts (ttPackageLocation taskType) (configCacheOpts cache) (configCacheDeps cache) mpkgid sublibsPkgIds (packageExes package) _ -> return () case taskType of -- For packages from a package index, pkgDir is in the tmp -- directory. We eagerly delete it if no other tasks -- require it, to reduce space usage in tmp (#3018). TTIndex{} -> do let remaining = filter (\(ActionId x _) -> x == taskProvides) (Set.toList acRemaining) when (null remaining) $ removeDirRecur pkgDir _ -> return () return mpkgid loadInstalledPkg wc pkgDbs tvar name = do dps <- ghcPkgDescribe name wc pkgDbs $ conduitDumpPackage .| CL.consume case dps of [] -> return Nothing [dp] -> do liftIO $ atomically $ modifyTVar' tvar (Map.insert (dpGhcPkgId dp) dp) return $ Just (dpGhcPkgId dp) _ -> error "singleBuild: invariant violated: multiple results when describing installed package" -- | Get the build status of all the package executables. Do so by -- testing whether their expected output file exists, e.g. -- -- .stack-work/dist/x86_64-osx/Cabal-1.22.4.0/build/alpha/alpha -- .stack-work/dist/x86_64-osx/Cabal-1.22.4.0/build/alpha/alpha.exe -- .stack-work/dist/x86_64-osx/Cabal-1.22.4.0/build/alpha/alpha.jsexe/ (NOTE: a dir) getExecutableBuildStatuses :: HasEnvConfig env => Package -> Path Abs Dir -> RIO env (Map Text ExecutableBuildStatus) getExecutableBuildStatuses package pkgDir = do compiler <- view $ actualCompilerVersionL.whichCompilerL distDir <- distDirFromDir pkgDir platform <- view platformL fmap M.fromList (mapM (checkExeStatus compiler platform distDir) (Set.toList (packageExes package))) -- | Check whether the given executable is defined in the given dist directory. checkExeStatus :: HasLogFunc env => WhichCompiler -> Platform -> Path b Dir -> Text -> RIO env (Text, ExecutableBuildStatus) checkExeStatus compiler platform distDir name = do exename <- parseRelDir (T.unpack name) exists <- checkPath (distDir $(mkRelDir "build") exename) pure ( name , if exists then ExecutableBuilt else ExecutableNotBuilt) where checkPath base = case compiler of Ghcjs -> do dir <- parseRelDir (file ++ ".jsexe") doesDirExist (base dir) _ -> case platform of Platform _ Windows -> do fileandext <- parseRelFile (file ++ ".exe") doesFileExist (base fileandext) _ -> do fileandext <- parseRelFile file doesFileExist (base fileandext) where file = T.unpack name -- | Check if any unlisted files have been found, and add them to the build cache. checkForUnlistedFiles :: HasEnvConfig env => TaskType -> ModTime -> Path Abs Dir -> RIO env [PackageWarning] checkForUnlistedFiles (TTFiles lp _) preBuildTime pkgDir = do (addBuildCache,warnings) <- addUnlistedToBuildCache preBuildTime (lpPackage lp) (lpCabalFile lp) (lpComponents lp) (lpNewBuildCaches lp) forM_ (M.toList addBuildCache) $ \(component, newToCache) -> do let cache = Map.findWithDefault Map.empty component (lpNewBuildCaches lp) writeBuildCache pkgDir component $ Map.unions (cache : newToCache) return warnings checkForUnlistedFiles TTIndex{} _ _ = return [] -- | Determine if all of the dependencies given are installed depsPresent :: InstalledMap -> Map PackageName VersionRange -> Bool depsPresent installedMap deps = all (\(name, range) -> case Map.lookup name installedMap of Just (_, installed) -> installedVersion installed `withinRange` range Nothing -> False) (Map.toList deps) -- | Implements running a package's tests. Also handles producing -- coverage reports if coverage is enabled. singleTest :: HasEnvConfig env => TestOpts -> [Text] -> ActionContext -> ExecuteEnv -> Task -> InstalledMap -> RIO env () singleTest topts testsToRun ac ee task installedMap = do -- FIXME: Since this doesn't use cabal, we should be able to avoid using a -- fullblown 'withSingleContext'. (allDepsMap, _cache) <- getConfigCache ee task installedMap True False withSingleContext ac ee task (Just allDepsMap) (Just "test") $ \package _cabalfp pkgDir _cabal announce outputType -> do config <- view configL let needHpc = toCoverage topts toRun <- if toDisableRun topts then do announce "Test running disabled by --no-run-tests flag." return False else if toRerunTests topts then return True else do success <- checkTestSuccess pkgDir if success then do unless (null testsToRun) $ announce "skipping already passed test" return False else return True when toRun $ do buildDir <- distDirFromDir pkgDir hpcDir <- hpcDirFromDir pkgDir when needHpc (ensureDir hpcDir) let suitesToRun = [ testSuitePair | testSuitePair <- Map.toList $ packageTests package , let testName = fst testSuitePair , testName `elem` testsToRun ] errs <- liftM Map.unions $ forM suitesToRun $ \(testName, suiteInterface) -> do let stestName = T.unpack testName (testName', isTestTypeLib) <- case suiteInterface of C.TestSuiteLibV09{} -> return (stestName ++ "Stub", True) C.TestSuiteExeV10{} -> return (stestName, False) interface -> throwM (TestSuiteTypeUnsupported interface) let exeName = testName' ++ case configPlatform config of Platform _ Windows -> ".exe" _ -> "" tixPath <- liftM (pkgDir ) $ parseRelFile $ exeName ++ ".tix" exePath <- liftM (buildDir ) $ parseRelFile $ "build/" ++ testName' ++ "/" ++ exeName exists <- doesFileExist exePath menv <- liftIO $ configProcessContextSettings config EnvSettings { esIncludeLocals = taskLocation task == Local , esIncludeGhcPackagePath = True , esStackExe = True , esLocaleUtf8 = False , esKeepGhcRts = False } withProcessContext menv $ if exists then do -- We clear out the .tix files before doing a run. when needHpc $ do tixexists <- doesFileExist tixPath when tixexists $ logWarn ("Removing HPC file " <> fromString (toFilePath tixPath)) liftIO $ ignoringAbsence (removeFile tixPath) let args = toAdditionalArgs topts argsDisplay = case args of [] -> "" _ -> ", args: " <> T.intercalate " " (map showProcessArgDebug args) announce $ "test (suite: " <> testName <> argsDisplay <> ")" -- Clear "Progress: ..." message before -- redirecting output. case outputType of OTConsole _ -> do logStickyDone "" liftIO $ hFlush stdout liftIO $ hFlush stderr OTLogFile _ _ -> pure () let output setter = case outputType of OTConsole _ -> id OTLogFile _ h -> setter (useHandleOpen h) ec <- withWorkingDir (toFilePath pkgDir) $ proc (toFilePath exePath) args $ \pc0 -> do let pc = setStdin createPipe $ output setStdout $ output setStderr pc0 withProcess pc $ \p -> do when isTestTypeLib $ do logPath <- buildLogPath package (Just stestName) ensureDir (parent logPath) liftIO $ hPutStr (getStdin p) $ show (logPath, testName) waitExitCode p -- Add a trailing newline, incase the test -- output didn't finish with a newline. case outputType of OTConsole _ -> logInfo "" OTLogFile _ _ -> pure () -- Move the .tix file out of the package -- directory into the hpc work dir, for -- tidiness. when needHpc $ updateTixFile (packageName package) tixPath testName' let announceResult result = announce $ "Test suite " <> testName <> " " <> result case ec of ExitSuccess -> do announceResult "passed" return Map.empty _ -> do announceResult "failed" return $ Map.singleton testName (Just ec) else do logError $ displayShow $ TestSuiteExeMissing (packageBuildType package == C.Simple) exeName (packageNameString (packageName package)) (T.unpack testName) return $ Map.singleton testName Nothing when needHpc $ do let testsToRun' = map f testsToRun f tName = case Map.lookup tName (packageTests package) of Just C.TestSuiteLibV09{} -> tName <> "Stub" _ -> tName generateHpcReport pkgDir package testsToRun' bs <- liftIO $ case outputType of OTConsole _ -> return "" OTLogFile logFile h -> do hClose h S.readFile $ toFilePath logFile unless (Map.null errs) $ throwM $ TestSuiteFailure (taskProvides task) errs (case outputType of OTLogFile fp _ -> Just fp OTConsole _ -> Nothing) bs setTestSuccess pkgDir -- | Implements running a package's benchmarks. singleBench :: HasEnvConfig env => BenchmarkOpts -> [Text] -> ActionContext -> ExecuteEnv -> Task -> InstalledMap -> RIO env () singleBench beopts benchesToRun ac ee task installedMap = do (allDepsMap, _cache) <- getConfigCache ee task installedMap False True withSingleContext ac ee task (Just allDepsMap) (Just "bench") $ \_package _cabalfp _pkgDir cabal announce _outputType -> do let args = map T.unpack benchesToRun <> maybe [] ((:[]) . ("--benchmark-options=" <>)) (beoAdditionalArgs beopts) toRun <- if beoDisableRun beopts then do announce "Benchmark running disabled by --no-run-benchmarks flag." return False else do return True when toRun $ do announce "benchmarks" cabal KeepTHLoading ("bench" : args) data ExcludeTHLoading = ExcludeTHLoading | KeepTHLoading data ConvertPathsToAbsolute = ConvertPathsToAbsolute | KeepPathsAsIs -- | Strip Template Haskell "Loading package" lines and making paths absolute. mungeBuildOutput :: forall m. MonadIO m => ExcludeTHLoading -- ^ exclude TH loading? -> ConvertPathsToAbsolute -- ^ convert paths to absolute? -> Path Abs Dir -- ^ package's root directory -> CompilerVersion 'CVActual -- ^ compiler we're building with -> ConduitM Text Text m () mungeBuildOutput excludeTHLoading makeAbsolute pkgDir compilerVer = void $ CT.lines .| CL.map stripCR .| CL.filter (not . isTHLoading) .| filterLinkerWarnings .| toAbsolute where -- | Is this line a Template Haskell "Loading package" line -- ByteString isTHLoading :: Text -> Bool isTHLoading = case excludeTHLoading of KeepTHLoading -> const False ExcludeTHLoading -> \bs -> "Loading package " `T.isPrefixOf` bs && ("done." `T.isSuffixOf` bs || "done.\r" `T.isSuffixOf` bs) filterLinkerWarnings :: ConduitM Text Text m () filterLinkerWarnings -- Check for ghc 7.8 since it's the only one prone to producing -- linker warnings on Windows x64 | getGhcVersion compilerVer >= $(mkVersion "7.8") = doNothing | otherwise = CL.filter (not . isLinkerWarning) isLinkerWarning :: Text -> Bool isLinkerWarning str = ("ghc.exe: warning:" `T.isPrefixOf` str || "ghc.EXE: warning:" `T.isPrefixOf` str) && "is linked instead of __imp_" `T.isInfixOf` str -- | Convert GHC error lines with file paths to have absolute file paths toAbsolute :: ConduitM Text Text m () toAbsolute = case makeAbsolute of KeepPathsAsIs -> doNothing ConvertPathsToAbsolute -> CL.mapM toAbsolutePath toAbsolutePath :: Text -> m Text toAbsolutePath bs = do let (x, y) = T.break (== ':') bs mabs <- if isValidSuffix y then liftIO $ liftM (fmap ((T.takeWhile isSpace x <>) . T.pack . toFilePath)) $ forgivingAbsence (resolveFile pkgDir (T.unpack $ T.dropWhile isSpace x)) `catch` \(_ :: PathException) -> return Nothing else return Nothing case mabs of Nothing -> return bs Just fp -> return $ fp `T.append` y doNothing :: ConduitM Text Text m () doNothing = awaitForever yield -- | Match the error location format at the end of lines isValidSuffix = isRight . parseOnly lineCol lineCol = char ':' >> choice [ num >> char ':' >> num >> optional (char '-' >> num) >> return () , char '(' >> num >> char ',' >> num >> string ")-(" >> num >> char ',' >> num >> char ')' >> return () ] >> char ':' >> return () where num = some digit -- | Find the Setup.hs or Setup.lhs in the given directory. If none exists, -- throw an exception. getSetupHs :: Path Abs Dir -- ^ project directory -> IO (Path Abs File) getSetupHs dir = do exists1 <- doesFileExist fp1 if exists1 then return fp1 else do exists2 <- doesFileExist fp2 if exists2 then return fp2 else throwM $ NoSetupHsFound dir where fp1 = dir $(mkRelFile "Setup.hs") fp2 = dir $(mkRelFile "Setup.lhs") -- Do not pass `-hpcdir` as GHC option if the coverage is not enabled. -- This helps running stack-compiled programs with dynamic interpreters like `hint`. -- Cfr: https://github.com/commercialhaskell/stack/issues/997 extraBuildOptions :: (HasEnvConfig env, HasRunner env) => WhichCompiler -> BuildOpts -> RIO env [String] extraBuildOptions wc bopts = do colorOpt <- appropriateGhcColorFlag let ddumpOpts = " -ddump-hi -ddump-to-file" optsFlag = compilerOptionsCabalFlag wc baseOpts = ddumpOpts ++ maybe "" (" " ++) colorOpt if toCoverage (boptsTestOpts bopts) then do hpcIndexDir <- toFilePathNoTrailingSep <$> hpcRelativeDir return [optsFlag, "-hpcdir " ++ hpcIndexDir ++ baseOpts] else return [optsFlag, baseOpts] -- Library, internal and foreign libraries and executable build components. primaryComponentOptions :: Map Text ExecutableBuildStatus -> LocalPackage -> [String] primaryComponentOptions executableBuildStatuses lp = -- TODO: get this information from target parsing instead, -- which will allow users to turn off library building if -- desired (case packageLibraries package of NoLibraries -> [] HasLibraries names -> map T.unpack $ T.append "lib:" (packageNameText (packageName package)) : map (T.append "flib:") (Set.toList names)) ++ map (T.unpack . T.append "lib:") (Set.toList $ packageInternalLibraries package) ++ map (T.unpack . T.append "exe:") (Set.toList $ exesToBuild executableBuildStatuses lp) where package = lpPackage lp -- | History of this function: -- -- * Normally it would do either all executables or if the user -- specified requested components, just build them. Afterwards, due -- to this Cabal bug , -- we had to make Stack build all executables every time. -- -- * In this -- was flagged up as very undesirable behavior on a large project, -- hence the behavior below that we build all executables once -- (modulo success), and thereafter pay attention to user-wanted -- components. -- exesToBuild :: Map Text ExecutableBuildStatus -> LocalPackage -> Set Text exesToBuild executableBuildStatuses lp = if cabalIsSatisfied executableBuildStatuses && lpWanted lp then exeComponents (lpComponents lp) else packageExes (lpPackage lp) -- | Do the current executables satisfy Cabal's bugged out requirements? cabalIsSatisfied :: Map k ExecutableBuildStatus -> Bool cabalIsSatisfied = all (== ExecutableBuilt) . M.elems -- Test-suite and benchmark build components. finalComponentOptions :: LocalPackage -> [String] finalComponentOptions lp = map (T.unpack . renderComponent) $ Set.toList $ Set.filter (\c -> isCTest c || isCBench c) (lpComponents lp) taskComponents :: Task -> Set NamedComponent taskComponents task = case taskType task of TTFiles lp _ -> lpComponents lp -- FIXME probably just want Local, maybe even just lpWanted TTIndex{} -> Set.empty -- | Take the given list of package dependencies and the contents of the global -- package database, and construct a set of installed package IDs that: -- -- * Excludes the Cabal library (it's added later) -- -- * Includes all packages depended on by this package -- -- * Includes all global packages, unless: (1) it's hidden, (2) it's shadowed -- by a depended-on package, or (3) one of its dependencies is not met. -- -- See: -- -- * https://github.com/commercialhaskell/stack/issues/941 -- -- * https://github.com/commercialhaskell/stack/issues/944 -- -- * https://github.com/commercialhaskell/stack/issues/949 addGlobalPackages :: Map PackageIdentifier GhcPkgId -- ^ dependencies of the package -> [DumpPackage () () ()] -- ^ global packages -> Set GhcPkgId addGlobalPackages deps globals0 = res where -- Initial set of packages: the installed IDs of all dependencies res0 = Map.elems $ Map.filterWithKey (\ident _ -> not $ isCabal ident) deps -- First check on globals: it's not shadowed by a dep, it's not Cabal, and -- it's exposed goodGlobal1 dp = not (isDep dp) && not (isCabal $ dpPackageIdent dp) && dpIsExposed dp globals1 = filter goodGlobal1 globals0 -- Create a Map of unique package names in the global database globals2 = Map.fromListWith chooseBest $ map (packageIdentifierName . dpPackageIdent &&& id) globals1 -- Final result: add in globals that have their dependencies met res = loop id (Map.elems globals2) $ Set.fromList res0 ---------------------------------- -- Some auxiliary helper functions ---------------------------------- -- Is the given package identifier for any version of Cabal isCabal (PackageIdentifier name _) = name == $(mkPackageName "Cabal") -- Is the given package name provided by the package dependencies? isDep dp = packageIdentifierName (dpPackageIdent dp) `Set.member` depNames depNames = Set.map packageIdentifierName $ Map.keysSet deps -- Choose the best of two competing global packages (the newest version) chooseBest dp1 dp2 | getVer dp1 < getVer dp2 = dp2 | otherwise = dp1 where getVer = packageIdentifierVersion . dpPackageIdent -- Are all dependencies of the given package met by the given Set of -- installed packages depsMet dp gids = all (`Set.member` gids) (dpDepends dp) -- Find all globals that have all of their dependencies met loop front (dp:dps) gids -- This package has its deps met. Add it to the list of dependencies -- and then traverse the list from the beginning (this package may have -- been a dependency of an earlier one). | depsMet dp gids = loop id (front dps) (Set.insert (dpGhcPkgId dp) gids) -- Deps are not met, keep going | otherwise = loop (front . (dp:)) dps gids -- None of the packages we checked can be added, therefore drop them all -- and return our results loop _ [] gids = gids stack-1.9.3.1/src/Stack/Build/Haddock.hs0000644000000000000000000003116513455617610015760 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude #-} {-# LANGUAGE ConstraintKinds #-} {-# LANGUAGE FlexibleContexts #-} {-# LANGUAGE MultiParamTypeClasses #-} {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE RecordWildCards #-} {-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE TemplateHaskell #-} -- | Generate haddocks module Stack.Build.Haddock ( generateLocalHaddockIndex , generateDepsHaddockIndex , generateSnapHaddockIndex , openHaddocksInBrowser , shouldHaddockPackage , shouldHaddockDeps ) where import Stack.Prelude import qualified Data.Foldable as F import qualified Data.HashSet as HS import qualified Data.Map.Strict as Map import qualified Data.Set as Set import Data.Time (UTCTime) import Path import Path.Extra import Path.IO import Stack.PackageDump import Stack.PrettyPrint import Stack.Types.Build import Stack.Types.Compiler import Stack.Types.Config import Stack.Types.GhcPkgId import Stack.Types.Package import Stack.Types.PackageIdentifier import Stack.Types.PackageName import Stack.Types.Runner import qualified System.FilePath as FP import RIO.Process import Web.Browser (openBrowser) openHaddocksInBrowser :: HasRunner env => BaseConfigOpts -> Map PackageName (PackageIdentifier, InstallLocation) -- ^ Available packages and their locations for the current project -> Set PackageName -- ^ Build targets as determined by 'Stack.Build.Source.loadSourceMap' -> RIO env () openHaddocksInBrowser bco pkgLocations buildTargets = do let cliTargets = (boptsCLITargets . bcoBuildOptsCLI) bco getDocIndex = do let localDocs = haddockIndexFile (localDepsDocDir bco) localExists <- doesFileExist localDocs if localExists then return localDocs else do let snapDocs = haddockIndexFile (snapDocDir bco) snapExists <- doesFileExist snapDocs if snapExists then return snapDocs else throwString "No local or snapshot doc index found to open." docFile <- case (cliTargets, map (`Map.lookup` pkgLocations) (Set.toList buildTargets)) of ([_], [Just (pkgId, iloc)]) -> do pkgRelDir <- (parseRelDir . packageIdentifierString) pkgId let docLocation = case iloc of Snap -> snapDocDir bco Local -> localDocDir bco let docFile = haddockIndexFile (docLocation pkgRelDir) exists <- doesFileExist docFile if exists then return docFile else do logWarn $ "Expected to find documentation at " <> fromString (toFilePath docFile) <> ", but that file is missing. Opening doc index instead." getDocIndex _ -> getDocIndex prettyInfo $ "Opening" <+> Stack.PrettyPrint.display docFile <+> "in the browser." _ <- liftIO $ openBrowser (toFilePath docFile) return () -- | Determine whether we should haddock for a package. shouldHaddockPackage :: BuildOpts -> Set PackageName -- ^ Packages that we want to generate haddocks for -- in any case (whether or not we are going to generate -- haddocks for dependencies) -> PackageName -> Bool shouldHaddockPackage bopts wanted name = if Set.member name wanted then boptsHaddock bopts else shouldHaddockDeps bopts -- | Determine whether to build haddocks for dependencies. shouldHaddockDeps :: BuildOpts -> Bool shouldHaddockDeps bopts = fromMaybe (boptsHaddock bopts) (boptsHaddockDeps bopts) -- | Generate Haddock index and contents for local packages. generateLocalHaddockIndex :: (HasProcessContext env, HasLogFunc env) => WhichCompiler -> BaseConfigOpts -> Map GhcPkgId (DumpPackage () () ()) -- ^ Local package dump -> [LocalPackage] -> RIO env () generateLocalHaddockIndex wc bco localDumpPkgs locals = do let dumpPackages = mapMaybe (\LocalPackage{lpPackage = Package{..}} -> F.find (\dp -> dpPackageIdent dp == PackageIdentifier packageName packageVersion) localDumpPkgs) locals generateHaddockIndex "local packages" wc bco dumpPackages "." (localDocDir bco) -- | Generate Haddock index and contents for local packages and their dependencies. generateDepsHaddockIndex :: (HasProcessContext env, HasLogFunc env) => WhichCompiler -> BaseConfigOpts -> Map GhcPkgId (DumpPackage () () ()) -- ^ Global dump information -> Map GhcPkgId (DumpPackage () () ()) -- ^ Snapshot dump information -> Map GhcPkgId (DumpPackage () () ()) -- ^ Local dump information -> [LocalPackage] -> RIO env () generateDepsHaddockIndex wc bco globalDumpPkgs snapshotDumpPkgs localDumpPkgs locals = do let deps = (mapMaybe (`lookupDumpPackage` allDumpPkgs) . nubOrd . findTransitiveDepends . mapMaybe getGhcPkgId) locals depDocDir = localDepsDocDir bco generateHaddockIndex "local packages and dependencies" wc bco deps ".." depDocDir where getGhcPkgId :: LocalPackage -> Maybe GhcPkgId getGhcPkgId LocalPackage{lpPackage = Package{..}} = let pkgId = PackageIdentifier packageName packageVersion mdpPkg = F.find (\dp -> dpPackageIdent dp == pkgId) localDumpPkgs in fmap dpGhcPkgId mdpPkg findTransitiveDepends :: [GhcPkgId] -> [GhcPkgId] findTransitiveDepends = (`go` HS.empty) . HS.fromList where go todo checked = case HS.toList todo of [] -> HS.toList checked (ghcPkgId:_) -> let deps = case lookupDumpPackage ghcPkgId allDumpPkgs of Nothing -> HS.empty Just pkgDP -> HS.fromList (dpDepends pkgDP) deps' = deps `HS.difference` checked todo' = HS.delete ghcPkgId (deps' `HS.union` todo) checked' = HS.insert ghcPkgId checked in go todo' checked' allDumpPkgs = [localDumpPkgs, snapshotDumpPkgs, globalDumpPkgs] -- | Generate Haddock index and contents for all snapshot packages. generateSnapHaddockIndex :: (HasProcessContext env, HasLogFunc env) => WhichCompiler -> BaseConfigOpts -> Map GhcPkgId (DumpPackage () () ()) -- ^ Global package dump -> Map GhcPkgId (DumpPackage () () ()) -- ^ Snapshot package dump -> RIO env () generateSnapHaddockIndex wc bco globalDumpPkgs snapshotDumpPkgs = generateHaddockIndex "snapshot packages" wc bco (Map.elems snapshotDumpPkgs ++ Map.elems globalDumpPkgs) "." (snapDocDir bco) -- | Generate Haddock index and contents for specified packages. generateHaddockIndex :: (HasProcessContext env, HasLogFunc env) => Text -> WhichCompiler -> BaseConfigOpts -> [DumpPackage () () ()] -> FilePath -> Path Abs Dir -> RIO env () generateHaddockIndex descr wc bco dumpPackages docRelFP destDir = do ensureDir destDir interfaceOpts <- (liftIO . fmap nubOrd . mapMaybeM toInterfaceOpt) dumpPackages unless (null interfaceOpts) $ do let destIndexFile = haddockIndexFile destDir eindexModTime <- liftIO (tryGetModificationTime destIndexFile) let needUpdate = case eindexModTime of Left _ -> True Right indexModTime -> or [mt > indexModTime | (_,mt,_,_) <- interfaceOpts] if needUpdate then do logInfo $ "Updating Haddock index for " <> Stack.Prelude.display descr <> " in\n" <> fromString (toFilePath destIndexFile) liftIO (mapM_ copyPkgDocs interfaceOpts) withWorkingDir (toFilePath destDir) $ readProcessNull (haddockExeName wc) (map (("--optghc=-package-db=" ++ ) . toFilePathNoTrailingSep) [bcoSnapDB bco, bcoLocalDB bco] ++ hoAdditionalArgs (boptsHaddockOpts (bcoBuildOpts bco)) ++ ["--gen-contents", "--gen-index"] ++ [x | (xs,_,_,_) <- interfaceOpts, x <- xs]) else logInfo $ "Haddock index for " <> Stack.Prelude.display descr <> " already up to date at:\n" <> fromString (toFilePath destIndexFile) where toInterfaceOpt :: DumpPackage a b c -> IO (Maybe ([String], UTCTime, Path Abs File, Path Abs File)) toInterfaceOpt DumpPackage {..} = case dpHaddockInterfaces of [] -> return Nothing srcInterfaceFP:_ -> do srcInterfaceAbsFile <- parseCollapsedAbsFile srcInterfaceFP let (PackageIdentifier name _) = dpPackageIdent destInterfaceRelFP = docRelFP FP. packageIdentifierString dpPackageIdent FP. (packageNameString name FP.<.> "haddock") destInterfaceAbsFile <- parseCollapsedAbsFile (toFilePath destDir FP. destInterfaceRelFP) esrcInterfaceModTime <- tryGetModificationTime srcInterfaceAbsFile return $ case esrcInterfaceModTime of Left _ -> Nothing Right srcInterfaceModTime -> Just ( [ "-i" , concat [ docRelFP FP. packageIdentifierString dpPackageIdent , "," , destInterfaceRelFP ]] , srcInterfaceModTime , srcInterfaceAbsFile , destInterfaceAbsFile ) copyPkgDocs :: (a, UTCTime, Path Abs File, Path Abs File) -> IO () copyPkgDocs (_,srcInterfaceModTime,srcInterfaceAbsFile,destInterfaceAbsFile) = do -- Copy dependencies' haddocks to documentation directory. This way, relative @../$pkg-$ver@ -- links work and it's easy to upload docs to a web server or otherwise view them in a -- non-local-filesystem context. We copy instead of symlink for two reasons: (1) symlinks -- aren't reliably supported on Windows, and (2) the filesystem containing dependencies' -- docs may not be available where viewing the docs (e.g. if building in a Docker -- container). edestInterfaceModTime <- tryGetModificationTime destInterfaceAbsFile case edestInterfaceModTime of Left _ -> doCopy Right destInterfaceModTime | destInterfaceModTime < srcInterfaceModTime -> doCopy | otherwise -> return () where doCopy = do ignoringAbsence (removeDirRecur destHtmlAbsDir) ensureDir destHtmlAbsDir onException (copyDirRecur' (parent srcInterfaceAbsFile) destHtmlAbsDir) (ignoringAbsence (removeDirRecur destHtmlAbsDir)) destHtmlAbsDir = parent destInterfaceAbsFile -- | Find first DumpPackage matching the GhcPkgId lookupDumpPackage :: GhcPkgId -> [Map GhcPkgId (DumpPackage () () ())] -> Maybe (DumpPackage () () ()) lookupDumpPackage ghcPkgId dumpPkgs = listToMaybe $ mapMaybe (Map.lookup ghcPkgId) dumpPkgs -- | Path of haddock index file. haddockIndexFile :: Path Abs Dir -> Path Abs File haddockIndexFile destDir = destDir $(mkRelFile "index.html") -- | Path of local packages documentation directory. localDocDir :: BaseConfigOpts -> Path Abs Dir localDocDir bco = bcoLocalInstallRoot bco docDirSuffix -- | Path of documentation directory for the dependencies of local packages localDepsDocDir :: BaseConfigOpts -> Path Abs Dir localDepsDocDir bco = localDocDir bco $(mkRelDir "all") -- | Path of snapshot packages documentation directory. snapDocDir :: BaseConfigOpts -> Path Abs Dir snapDocDir bco = bcoSnapInstallRoot bco docDirSuffix stack-1.9.3.1/src/Stack/Build/Installed.hs0000644000000000000000000003030313455617610016333 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude #-} {-# LANGUAGE ConstraintKinds #-} {-# LANGUAGE FlexibleContexts #-} {-# LANGUAGE MultiParamTypeClasses #-} {-# LANGUAGE OverloadedStrings #-} -- Determine which packages are already installed module Stack.Build.Installed ( InstalledMap , Installed (..) , GetInstalledOpts (..) , getInstalled ) where import Data.Conduit import qualified Data.Conduit.List as CL import qualified Data.Foldable as F import qualified Data.HashSet as HashSet import Data.List import qualified Data.Map.Strict as Map import Path import Stack.Build.Cache import Stack.Constants import Stack.PackageDump import Stack.Prelude import Stack.Types.Build import Stack.Types.Compiler import Stack.Types.Config import Stack.Types.GhcPkgId import Stack.Types.Package import Stack.Types.PackageDump import Stack.Types.PackageIdentifier import Stack.Types.PackageName import Stack.Types.Version -- | Options for 'getInstalled'. data GetInstalledOpts = GetInstalledOpts { getInstalledProfiling :: !Bool -- ^ Require profiling libraries? , getInstalledHaddock :: !Bool -- ^ Require haddocks? , getInstalledSymbols :: !Bool -- ^ Require debugging symbols? } -- | Returns the new InstalledMap and all of the locally registered packages. getInstalled :: HasEnvConfig env => GetInstalledOpts -> Map PackageName PackageSource -- ^ does not contain any installed information -> RIO env ( InstalledMap , [DumpPackage () () ()] -- globally installed , [DumpPackage () () ()] -- snapshot installed , [DumpPackage () () ()] -- locally installed ) getInstalled opts sourceMap = do logDebug "Finding out which packages are already installed" snapDBPath <- packageDatabaseDeps localDBPath <- packageDatabaseLocal extraDBPaths <- packageDatabaseExtra mcache <- if getInstalledProfiling opts || getInstalledHaddock opts then configInstalledCache >>= liftM Just . loadInstalledCache else return Nothing let loadDatabase' = loadDatabase opts mcache sourceMap (installedLibs0, globalDumpPkgs) <- loadDatabase' Nothing [] (installedLibs1, _extraInstalled) <- foldM (\lhs' pkgdb -> loadDatabase' (Just (ExtraGlobal, pkgdb)) (fst lhs') ) (installedLibs0, globalDumpPkgs) extraDBPaths (installedLibs2, snapshotDumpPkgs) <- loadDatabase' (Just (InstalledTo Snap, snapDBPath)) installedLibs1 (installedLibs3, localDumpPkgs) <- loadDatabase' (Just (InstalledTo Local, localDBPath)) installedLibs2 let installedLibs = Map.fromList $ map lhPair installedLibs3 F.forM_ mcache $ \cache -> do icache <- configInstalledCache saveInstalledCache icache cache -- Add in the executables that are installed, making sure to only trust a -- listed installation under the right circumstances (see below) let exesToSM loc = Map.unions . map (exeToSM loc) exeToSM loc (PackageIdentifier name version) = case Map.lookup name sourceMap of -- Doesn't conflict with anything, so that's OK Nothing -> m Just pii -- Not the version we want, ignore it | version /= piiVersion pii || loc /= piiLocation pii -> Map.empty | otherwise -> m where m = Map.singleton name (loc, Executable $ PackageIdentifier name version) exesSnap <- getInstalledExes Snap exesLocal <- getInstalledExes Local let installedMap = Map.unions [ exesToSM Local exesLocal , exesToSM Snap exesSnap , installedLibs ] return ( installedMap , globalDumpPkgs , snapshotDumpPkgs , localDumpPkgs ) -- | Outputs both the modified InstalledMap and the Set of all installed packages in this database -- -- The goal is to ascertain that the dependencies for a package are present, -- that it has profiling if necessary, and that it matches the version and -- location needed by the SourceMap loadDatabase :: HasEnvConfig env => GetInstalledOpts -> Maybe InstalledCache -- ^ if Just, profiling or haddock is required -> Map PackageName PackageSource -- ^ to determine which installed things we should include -> Maybe (InstalledPackageLocation, Path Abs Dir) -- ^ package database, Nothing for global -> [LoadHelper] -- ^ from parent databases -> RIO env ([LoadHelper], [DumpPackage () () ()]) loadDatabase opts mcache sourceMap mdb lhs0 = do wc <- view $ actualCompilerVersionL.to whichCompiler (lhs1', dps) <- ghcPkgDump wc (fmap snd (maybeToList mdb)) $ conduitDumpPackage .| sink let ghcjsHack = wc == Ghcjs && isNothing mdb lhs1 <- mapMaybeM (processLoadResult mdb ghcjsHack) lhs1' let lhs = pruneDeps id lhId lhDeps const (lhs0 ++ lhs1) return (map (\lh -> lh { lhDeps = [] }) $ Map.elems lhs, dps) where conduitProfilingCache = case mcache of Just cache | getInstalledProfiling opts -> addProfiling cache -- Just an optimization to avoid calculating the profiling -- values when they aren't necessary _ -> CL.map (\dp -> dp { dpProfiling = False }) conduitHaddockCache = case mcache of Just cache | getInstalledHaddock opts -> addHaddock cache -- Just an optimization to avoid calculating the haddock -- values when they aren't necessary _ -> CL.map (\dp -> dp { dpHaddock = False }) conduitSymbolsCache = case mcache of Just cache | getInstalledSymbols opts -> addSymbols cache -- Just an optimization to avoid calculating the debugging -- symbol values when they aren't necessary _ -> CL.map (\dp -> dp { dpSymbols = False }) mloc = fmap fst mdb sinkDP = conduitProfilingCache .| conduitHaddockCache .| conduitSymbolsCache .| CL.map (isAllowed opts mcache sourceMap mloc &&& toLoadHelper mloc) .| CL.consume sink = getZipSink $ (,) <$> ZipSink sinkDP <*> ZipSink CL.consume processLoadResult :: HasLogFunc env => Maybe (InstalledPackageLocation, Path Abs Dir) -> Bool -> (Allowed, LoadHelper) -> RIO env (Maybe LoadHelper) processLoadResult _ _ (Allowed, lh) = return (Just lh) processLoadResult _ True (WrongVersion actual wanted, lh) -- Allow some packages in the ghcjs global DB to have the wrong -- versions. Treat them as wired-ins by setting deps to []. | fst (lhPair lh) `HashSet.member` ghcjsBootPackages = do logWarn $ "Ignoring that the GHCJS boot package \"" <> display (packageNameText (fst (lhPair lh))) <> "\" has a different version, " <> display (versionText actual) <> ", than the resolver's wanted version, " <> display (versionText wanted) return (Just lh) processLoadResult mdb _ (reason, lh) = do logDebug $ "Ignoring package " <> display (packageNameText (fst (lhPair lh))) <> maybe mempty (\db -> ", from " <> displayShow db <> ",") mdb <> " due to" <> case reason of Allowed -> " the impossible?!?!" NeedsProfiling -> " it needing profiling." NeedsHaddock -> " it needing haddocks." NeedsSymbols -> " it needing debugging symbols." UnknownPkg -> " it being unknown to the resolver / extra-deps." WrongLocation mloc loc -> " wrong location: " <> displayShow (mloc, loc) WrongVersion actual wanted -> " wanting version " <> display (versionText wanted) <> " instead of " <> display (versionText actual) return Nothing data Allowed = Allowed | NeedsProfiling | NeedsHaddock | NeedsSymbols | UnknownPkg | WrongLocation (Maybe InstalledPackageLocation) InstallLocation | WrongVersion Version Version deriving (Eq, Show) -- | Check if a can be included in the set of installed packages or not, based -- on the package selections made by the user. This does not perform any -- dirtiness or flag change checks. isAllowed :: GetInstalledOpts -> Maybe InstalledCache -> Map PackageName PackageSource -> Maybe InstalledPackageLocation -> DumpPackage Bool Bool Bool -> Allowed isAllowed opts mcache sourceMap mloc dp -- Check that it can do profiling if necessary | getInstalledProfiling opts && isJust mcache && not (dpProfiling dp) = NeedsProfiling -- Check that it has haddocks if necessary | getInstalledHaddock opts && isJust mcache && not (dpHaddock dp) = NeedsHaddock -- Check that it has haddocks if necessary | getInstalledSymbols opts && isJust mcache && not (dpSymbols dp) = NeedsSymbols | otherwise = case Map.lookup name sourceMap of Nothing -> -- If the sourceMap has nothing to say about this package, -- check if it represents a sublibrary first -- See: https://github.com/commercialhaskell/stack/issues/3899 case dpParentLibIdent dp of Just (PackageIdentifier parentLibName version') -> case Map.lookup parentLibName sourceMap of Nothing -> checkNotFound Just pii | version' == version -> checkFound pii | otherwise -> checkNotFound -- different versions Nothing -> checkNotFound Just pii -> checkFound pii where PackageIdentifier name version = dpPackageIdent dp -- Ensure that the installed location matches where the sourceMap says it -- should be installed checkLocation Snap = mloc /= Just (InstalledTo Local) -- we can allow either global or snap checkLocation Local = mloc == Just (InstalledTo Local) || mloc == Just ExtraGlobal -- 'locally' installed snapshot packages can come from extra dbs -- Check if a package is allowed if it is found in the sourceMap checkFound pii | not (checkLocation (piiLocation pii)) = WrongLocation mloc (piiLocation pii) | version /= piiVersion pii = WrongVersion version (piiVersion pii) | otherwise = Allowed -- check if a package is allowed if it is not found in the sourceMap checkNotFound = case mloc of -- The sourceMap has nothing to say about this global package, so we can use it Nothing -> Allowed Just ExtraGlobal -> Allowed -- For non-global packages, don't include unknown packages. -- See: https://github.com/commercialhaskell/stack/issues/292 Just _ -> UnknownPkg data LoadHelper = LoadHelper { lhId :: !GhcPkgId , lhDeps :: ![GhcPkgId] , lhPair :: !(PackageName, (InstallLocation, Installed)) } deriving Show toLoadHelper :: Maybe InstalledPackageLocation -> DumpPackage Bool Bool Bool -> LoadHelper toLoadHelper mloc dp = LoadHelper { lhId = gid , lhDeps = -- We always want to consider the wired in packages as having all -- of their dependencies installed, since we have no ability to -- reinstall them. This is especially important for using different -- minor versions of GHC, where the dependencies of wired-in -- packages may change slightly and therefore not match the -- snapshot. if name `HashSet.member` wiredInPackages then [] else dpDepends dp , lhPair = (name, (toPackageLocation mloc, Library ident gid (Right <$> dpLicense dp))) } where gid = dpGhcPkgId dp ident@(PackageIdentifier name _) = dpPackageIdent dp toPackageLocation :: Maybe InstalledPackageLocation -> InstallLocation toPackageLocation Nothing = Snap toPackageLocation (Just ExtraGlobal) = Snap toPackageLocation (Just (InstalledTo loc)) = loc stack-1.9.3.1/src/Stack/Build/Source.hs0000644000000000000000000005106113455666157015672 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude #-} {-# LANGUAGE FlexibleContexts #-} {-# LANGUAGE MultiParamTypeClasses #-} {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TupleSections #-} {-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE ConstraintKinds #-} -- Load information on package sources module Stack.Build.Source ( loadSourceMap , loadSourceMapFull , SourceMap , getLocalFlags , getGhcOptions , addUnlistedToBuildCache ) where import Stack.Prelude import Crypto.Hash (Digest, SHA256(..)) import Crypto.Hash.Conduit (sinkHash) import qualified Data.ByteArray as Mem (convert) import qualified Data.ByteString as S import Data.Conduit (ZipSink (..)) import qualified Data.Conduit.List as CL import qualified Data.HashSet as HashSet import Data.List import qualified Data.Map as Map import qualified Data.Map.Strict as M import qualified Data.Set as Set import Stack.Build.Cache import Stack.Build.Target import Stack.Config (getLocalPackages) import Stack.Constants (wiredInPackages) import Stack.Package import Stack.PackageLocation import Stack.Types.Build import Stack.Types.BuildPlan import Stack.Types.Config import Stack.Types.FlagName import Stack.Types.NamedComponent import Stack.Types.Package import Stack.Types.PackageName import qualified System.Directory as D import System.FilePath (takeFileName) import System.IO.Error (isDoesNotExistError) -- | Like 'loadSourceMapFull', but doesn't return values that aren't as -- commonly needed. loadSourceMap :: HasEnvConfig env => NeedTargets -> BuildOptsCLI -> RIO env ([LocalPackage], SourceMap) loadSourceMap needTargets boptsCli = do (_, _, locals, _, sourceMap) <- loadSourceMapFull needTargets boptsCli return (locals, sourceMap) -- | Given the build commandline options, does the following: -- -- * Parses the build targets. -- -- * Loads the 'LoadedSnapshot' from the resolver, with extra-deps -- shadowing any packages that should be built locally. -- -- * Loads up the 'LocalPackage' info. -- -- * Builds a 'SourceMap', which contains info for all the packages that -- will be involved in the build. loadSourceMapFull :: HasEnvConfig env => NeedTargets -> BuildOptsCLI -> RIO env ( Map PackageName Target , LoadedSnapshot , [LocalPackage] -- FIXME do we really want this? it's in the SourceMap , Set PackageName -- non-project targets , SourceMap ) loadSourceMapFull needTargets boptsCli = do bconfig <- view buildConfigL (ls, localDeps, targets) <- parseTargets needTargets boptsCli lp <- getLocalPackages locals <- mapM (loadLocalPackage True boptsCli targets) $ Map.toList $ lpProject lp checkFlagsUsed boptsCli locals localDeps (lsPackages ls) checkComponentsBuildable locals -- TODO for extra sanity, confirm that the targets we threw away are all TargetAll let nonProjectTargets = Map.keysSet targets `Set.difference` Map.keysSet (lpProject lp) -- Combine the local packages, extra-deps, and LoadedSnapshot into -- one unified source map. let goLPI loc n lpi = do let configOpts = getGhcOptions bconfig boptsCli n False False case lpiLocation lpi of -- NOTE: configOpts includes lpiGhcOptions for now, this may get refactored soon PLIndex pir -> return $ PSIndex loc (lpiFlags lpi) configOpts pir PLOther pl -> do root <- view projectRootL lpv <- parseSingleCabalFile root True pl lp' <- loadLocalPackage False boptsCli targets (n, lpv) return $ PSFiles lp' loc sourceMap' <- Map.unions <$> sequence [ return $ Map.fromList $ map (\lp' -> (packageName $ lpPackage lp', PSFiles lp' Local)) locals , sequence $ Map.mapWithKey (goLPI Local) localDeps , sequence $ Map.mapWithKey (goLPI Snap) (lsPackages ls) ] let sourceMap = sourceMap' `Map.difference` Map.fromList (map (, ()) (HashSet.toList wiredInPackages)) return ( targets , ls , locals , nonProjectTargets , sourceMap ) -- | All flags for a local package. getLocalFlags :: BuildConfig -> BuildOptsCLI -> PackageName -> Map FlagName Bool getLocalFlags bconfig boptsCli name = Map.unions [ Map.findWithDefault Map.empty (Just name) cliFlags , Map.findWithDefault Map.empty Nothing cliFlags , Map.findWithDefault Map.empty name (bcFlags bconfig) ] where cliFlags = boptsCLIFlags boptsCli -- | Get the configured options to pass from GHC, based on the build -- configuration and commandline. getGhcOptions :: BuildConfig -> BuildOptsCLI -> PackageName -> Bool -> Bool -> [Text] getGhcOptions bconfig boptsCli name isTarget isLocal = concat [ Map.findWithDefault [] AGOEverything (configGhcOptionsByCat config) , if isLocal then Map.findWithDefault [] AGOLocals (configGhcOptionsByCat config) else [] , if isTarget then Map.findWithDefault [] AGOTargets (configGhcOptionsByCat config) else [] , Map.findWithDefault [] name (configGhcOptionsByName config) , concat [["-fhpc"] | isLocal && toCoverage (boptsTestOpts bopts)] , if boptsLibProfile bopts || boptsExeProfile bopts then ["-fprof-auto","-fprof-cafs"] else [] , if not $ boptsLibStrip bopts || boptsExeStrip bopts then ["-g"] else [] , if includeExtraOptions then boptsCLIGhcOptions boptsCli else [] ] where bopts = configBuild config config = view configL bconfig includeExtraOptions = case configApplyGhcOptions config of AGOTargets -> isTarget AGOLocals -> isLocal AGOEverything -> True splitComponents :: [NamedComponent] -> (Set Text, Set Text, Set Text) splitComponents = go id id id where go a b c [] = (Set.fromList $ a [], Set.fromList $ b [], Set.fromList $ c []) go a b c (CLib:xs) = go a b c xs go a b c (CInternalLib x:xs) = go (a . (x:)) b c xs go a b c (CExe x:xs) = go (a . (x:)) b c xs go a b c (CTest x:xs) = go a (b . (x:)) c xs go a b c (CBench x:xs) = go a b (c . (x:)) xs -- | Upgrade the initial local package info to a full-blown @LocalPackage@ -- based on the selected components loadLocalPackage :: forall env. HasEnvConfig env => Bool -- ^ Should this be treated as part of $locals? False for extra-deps. -- -- See: https://github.com/commercialhaskell/stack/issues/3574#issuecomment-346512821 -> BuildOptsCLI -> Map PackageName Target -> (PackageName, LocalPackageView) -> RIO env LocalPackage loadLocalPackage isLocal boptsCli targets (name, lpv) = do let mtarget = Map.lookup name targets config <- getPackageConfig boptsCli name (isJust mtarget) isLocal bopts <- view buildOptsL let (exeCandidates, testCandidates, benchCandidates) = case mtarget of Just (TargetComps comps) -> splitComponents $ Set.toList comps Just (TargetAll _packageType) -> ( packageExes pkg , if boptsTests bopts then Map.keysSet (packageTests pkg) else Set.empty , if boptsBenchmarks bopts then packageBenchmarks pkg else Set.empty ) Nothing -> mempty -- See https://github.com/commercialhaskell/stack/issues/2862 isWanted = case mtarget of Nothing -> False -- FIXME: When issue #1406 ("stack 0.1.8 lost ability to -- build individual executables or library") is resolved, -- 'hasLibrary' is only relevant if the library is -- part of the target spec. Just _ -> let hasLibrary = case packageLibraries pkg of NoLibraries -> False HasLibraries _ -> True in hasLibrary || not (Set.null nonLibComponents) || not (Set.null $ packageInternalLibraries pkg) filterSkippedComponents = Set.filter (not . (`elem` boptsSkipComponents bopts)) (exes, tests, benches) = (filterSkippedComponents exeCandidates, filterSkippedComponents testCandidates, filterSkippedComponents benchCandidates) nonLibComponents = toComponents exes tests benches toComponents e t b = Set.unions [ Set.map CExe e , Set.map CTest t , Set.map CBench b ] btconfig = config { packageConfigEnableTests = not $ Set.null tests , packageConfigEnableBenchmarks = not $ Set.null benches } testconfig = config { packageConfigEnableTests = True , packageConfigEnableBenchmarks = False } benchconfig = config { packageConfigEnableTests = False , packageConfigEnableBenchmarks = True } -- We resolve the package in 4 different configurations: -- -- - pkg doesn't have tests or benchmarks enabled. -- -- - btpkg has them enabled if they are present. -- -- - testpkg has tests enabled, but not benchmarks. -- -- - benchpkg has benchmarks enablde, but not tests. -- -- The latter two configurations are used to compute the deps -- when --enable-benchmarks or --enable-tests are configured. -- This allows us to do an optimization where these are passed -- if the deps are present. This can avoid doing later -- unnecessary reconfigures. gpkg = lpvGPD lpv pkg = resolvePackage config gpkg btpkg | Set.null tests && Set.null benches = Nothing | otherwise = Just (resolvePackage btconfig gpkg) testpkg = resolvePackage testconfig gpkg benchpkg = resolvePackage benchconfig gpkg (componentFiles,_) <- getPackageFilesForTargets pkg (lpvCabalFP lpv) nonLibComponents checkCacheResults <- forM (Map.toList componentFiles) $ \(component, files) -> do mbuildCache <- tryGetBuildCache (lpvRoot lpv) component checkCacheResult <- checkBuildCache (fromMaybe Map.empty mbuildCache) (Set.toList files) return (component, checkCacheResult) let allDirtyFiles = Set.unions $ map (\(_, (dirtyFiles, _)) -> dirtyFiles) checkCacheResults newBuildCaches = M.fromList $ map (\(c, (_, cache)) -> (c, cache)) checkCacheResults return LocalPackage { lpPackage = pkg , lpTestDeps = dvVersionRange <$> packageDeps testpkg , lpBenchDeps = dvVersionRange <$> packageDeps benchpkg , lpTestBench = btpkg , lpComponentFiles = componentFiles , lpForceDirty = boptsForceDirty bopts , lpDirtyFiles = if not (Set.null allDirtyFiles) then let tryStripPrefix y = fromMaybe y (stripPrefix (toFilePath $ lpvRoot lpv) y) in Just $ Set.map tryStripPrefix allDirtyFiles else Nothing , lpNewBuildCaches = newBuildCaches , lpCabalFile = lpvCabalFP lpv , lpDir = lpvRoot lpv , lpWanted = isWanted , lpComponents = nonLibComponents -- TODO: refactor this so that it's easier to be sure that these -- components are indeed unbuildable. -- -- The reasoning here is that if the STLocalComps specification -- made it through component parsing, but the components aren't -- present, then they must not be buildable. , lpUnbuildable = toComponents (exes `Set.difference` packageExes pkg) (tests `Set.difference` Map.keysSet (packageTests pkg)) (benches `Set.difference` packageBenchmarks pkg) , lpLocation = lpvLoc lpv } -- | Ensure that the flags specified in the stack.yaml file and on the command -- line are used. checkFlagsUsed :: (MonadThrow m, MonadReader env m, HasBuildConfig env) => BuildOptsCLI -> [LocalPackage] -> Map PackageName (LoadedPackageInfo (PackageLocationIndex FilePath)) -- ^ local deps -> Map PackageName snapshot -- ^ snapshot, for error messages -> m () checkFlagsUsed boptsCli lps extraDeps snapshot = do bconfig <- view buildConfigL -- Check if flags specified in stack.yaml and the command line are -- used, see https://github.com/commercialhaskell/stack/issues/617 let flags = map (, FSCommandLine) [(k, v) | (Just k, v) <- Map.toList $ boptsCLIFlags boptsCli] ++ map (, FSStackYaml) (Map.toList $ bcFlags bconfig) localNameMap = Map.fromList $ map (packageName . lpPackage &&& lpPackage) lps checkFlagUsed ((name, userFlags), source) = case Map.lookup name localNameMap of -- Package is not available locally Nothing -> if Map.member name extraDeps -- We don't check for flag presence for extra deps then Nothing -- Also not in extra-deps, it's an error else case Map.lookup name snapshot of Nothing -> Just $ UFNoPackage source name Just _ -> Just $ UFSnapshot name -- Package exists locally, let's check if the flags are defined Just pkg -> let unused = Set.difference (Map.keysSet userFlags) (packageDefinedFlags pkg) in if Set.null unused -- All flags are defined, nothing to do then Nothing -- Error about the undefined flags else Just $ UFFlagsNotDefined source pkg unused unusedFlags = mapMaybe checkFlagUsed flags unless (null unusedFlags) $ throwM $ InvalidFlagSpecification $ Set.fromList unusedFlags -- | Compare the current filesystem state to the cached information, and -- determine (1) if the files are dirty, and (2) the new cache values. checkBuildCache :: forall m. (MonadIO m) => Map FilePath FileCacheInfo -- ^ old cache -> [Path Abs File] -- ^ files in package -> m (Set FilePath, Map FilePath FileCacheInfo) checkBuildCache oldCache files = do fileTimes <- liftM Map.fromList $ forM files $ \fp -> do mmodTime <- liftIO (getModTimeMaybe (toFilePath fp)) return (toFilePath fp, mmodTime) liftM (mconcat . Map.elems) $ sequence $ Map.mergeWithKey (\fp mmodTime fci -> Just (go fp mmodTime (Just fci))) (Map.mapWithKey (\fp mmodTime -> go fp mmodTime Nothing)) (Map.mapWithKey (\fp fci -> go fp Nothing (Just fci))) fileTimes oldCache where go :: FilePath -> Maybe ModTime -> Maybe FileCacheInfo -> m (Set FilePath, Map FilePath FileCacheInfo) -- Filter out the cabal_macros file to avoid spurious recompilations go fp _ _ | takeFileName fp == "cabal_macros.h" = return (Set.empty, Map.empty) -- Common case where it's in the cache and on the filesystem. go fp (Just modTime') (Just fci) | fciModTime fci == modTime' = return (Set.empty, Map.singleton fp fci) | otherwise = do newFci <- calcFci modTime' fp let isDirty = fciSize fci /= fciSize newFci || fciHash fci /= fciHash newFci newDirty = if isDirty then Set.singleton fp else Set.empty return (newDirty, Map.singleton fp newFci) -- Missing file. Add it to dirty files, but no FileCacheInfo. go fp Nothing _ = return (Set.singleton fp, Map.empty) -- Missing cache. Add it to dirty files and compute FileCacheInfo. go fp (Just modTime') Nothing = do newFci <- calcFci modTime' fp return (Set.singleton fp, Map.singleton fp newFci) -- | Returns entries to add to the build cache for any newly found unlisted modules addUnlistedToBuildCache :: HasEnvConfig env => ModTime -> Package -> Path Abs File -> Set NamedComponent -> Map NamedComponent (Map FilePath a) -> RIO env (Map NamedComponent [Map FilePath FileCacheInfo], [PackageWarning]) addUnlistedToBuildCache preBuildTime pkg cabalFP nonLibComponents buildCaches = do (componentFiles, warnings) <- getPackageFilesForTargets pkg cabalFP nonLibComponents results <- forM (M.toList componentFiles) $ \(component, files) -> do let buildCache = M.findWithDefault M.empty component buildCaches newFiles = Set.toList $ Set.map toFilePath files `Set.difference` Map.keysSet buildCache addBuildCache <- mapM addFileToCache newFiles return ((component, addBuildCache), warnings) return (M.fromList (map fst results), concatMap snd results) where addFileToCache fp = do mmodTime <- getModTimeMaybe fp case mmodTime of Nothing -> return Map.empty Just modTime' -> if modTime' < preBuildTime then Map.singleton fp <$> calcFci modTime' fp else return Map.empty -- | Gets list of Paths for files relevant to a set of components in a package. -- Note that the library component, if any, is always automatically added to the -- set of components. getPackageFilesForTargets :: HasEnvConfig env => Package -> Path Abs File -> Set NamedComponent -> RIO env (Map NamedComponent (Set (Path Abs File)), [PackageWarning]) getPackageFilesForTargets pkg cabalFP nonLibComponents = do (components',compFiles,otherFiles,warnings) <- getPackageFiles (packageFiles pkg) cabalFP let necessaryComponents = Set.insert CLib $ Set.filter isCInternalLib (M.keysSet components') components = necessaryComponents `Set.union` nonLibComponents componentsFiles = M.map (\files -> Set.union otherFiles (Set.map dotCabalGetPath files)) $ M.filterWithKey (\component _ -> component `Set.member` components) compFiles return (componentsFiles, warnings) -- | Get file modification time, if it exists. getModTimeMaybe :: MonadIO m => FilePath -> m (Maybe ModTime) getModTimeMaybe fp = liftIO (catch (liftM (Just . modTime) (D.getModificationTime fp)) (\e -> if isDoesNotExistError e then return Nothing else throwM e)) -- | Create FileCacheInfo for a file. calcFci :: MonadIO m => ModTime -> FilePath -> m FileCacheInfo calcFci modTime' fp = liftIO $ withSourceFile fp $ \src -> do (size, digest) <- runConduit $ src .| getZipSink ((,) <$> ZipSink (CL.fold (\x y -> x + fromIntegral (S.length y)) 0) <*> ZipSink sinkHash) return FileCacheInfo { fciModTime = modTime' , fciSize = size , fciHash = Mem.convert (digest :: Digest SHA256) } checkComponentsBuildable :: MonadThrow m => [LocalPackage] -> m () checkComponentsBuildable lps = unless (null unbuildable) $ throwM $ SomeTargetsNotBuildable unbuildable where unbuildable = [ (packageName (lpPackage lp), c) | lp <- lps , c <- Set.toList (lpUnbuildable lp) ] -- | Get 'PackageConfig' for package given its name. getPackageConfig :: (MonadIO m, MonadReader env m, HasEnvConfig env) => BuildOptsCLI -> PackageName -> Bool -> Bool -> m PackageConfig getPackageConfig boptsCli name isTarget isLocal = do bconfig <- view buildConfigL platform <- view platformL compilerVersion <- view actualCompilerVersionL return PackageConfig { packageConfigEnableTests = False , packageConfigEnableBenchmarks = False , packageConfigFlags = getLocalFlags bconfig boptsCli name , packageConfigGhcOptions = getGhcOptions bconfig boptsCli name isTarget isLocal , packageConfigCompilerVersion = compilerVersion , packageConfigPlatform = platform } stack-1.9.3.1/src/Stack/Build/Target.hs0000644000000000000000000005541413455617610015654 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude #-} {-# LANGUAGE DataKinds #-} {-# LANGUAGE GADTs #-} {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE TupleSections #-} {-# LANGUAGE ViewPatterns #-} -- | Parsing command line targets -- -- There are two relevant data sources for performing this parsing: -- the project configuration, and command line arguments. Project -- configurations includes the resolver (defining a LoadedSnapshot of -- global and snapshot packages), local dependencies, and project -- packages. It also defines local flag overrides. -- -- The command line arguments specify both additional local flag -- overrides and targets in their raw form. -- -- Flags are simple: we just combine CLI flags with config flags and -- make one big map of flags, preferring CLI flags when present. -- -- Raw targets can be a package name, a package name with component, -- just a component, or a package name and version number. We first -- must resolve these raw targets into both simple targets and -- additional dependencies. This works as follows: -- -- * If a component is specified, find a unique project package which -- defines that component, and convert it into a name+component -- target. -- -- * Ensure that all name+component values refer to valid components -- in the given project package. -- -- * For names, check if the name is present in the snapshot, local -- deps, or project packages. If it is not, then look up the most -- recent version in the package index and convert to a -- name+version. -- -- * For name+version, first ensure that the name is not used by a -- project package. Next, if that name+version is present in the -- snapshot or local deps _and_ its location is PLIndex, we have the -- package. Otherwise, add to local deps with the appropriate -- PLIndex. -- -- If in either of the last two bullets we added a package to local -- deps, print a warning to the user recommending modifying the -- extra-deps. -- -- Combine the various 'ResolveResults's together into 'Target' -- values, by combining various components for a single package and -- ensuring that no conflicting statements were made about targets. -- -- At this point, we now have a Map from package name to SimpleTarget, -- and an updated Map of local dependencies. We still have the -- aggregated flags, and the snapshot and project packages. -- -- Finally, we upgrade the snapshot by using -- calculatePackagePromotion. module Stack.Build.Target ( -- * Types Target (..) , NeedTargets (..) , PackageType (..) , parseTargets -- * Convenience helpers , gpdVersion -- * Test suite exports , parseRawTarget , RawTarget (..) , UnresolvedComponent (..) ) where import Stack.Prelude import qualified Data.HashMap.Strict as HashMap import qualified Data.Map as Map import qualified Data.Set as Set import qualified Data.Text as T import Distribution.PackageDescription (GenericPackageDescription, package, packageDescription) import Path import Path.Extra (rejectMissingDir) import Path.IO import Stack.Config (getLocalPackages) import Stack.PackageIndex import Stack.PackageLocation import Stack.Snapshot (calculatePackagePromotion) import Stack.Types.Config import Stack.Types.NamedComponent import Stack.Types.PackageIdentifier import Stack.Types.PackageName import Stack.Types.Version import Stack.Types.Build import Stack.Types.BuildPlan import Stack.Types.GhcPkgId -- | Do we need any targets? For example, `stack build` will fail if -- no targets are provided. data NeedTargets = NeedTargets | AllowNoTargets --------------------------------------------------------------------------------- -- Get the RawInput --------------------------------------------------------------------------------- -- | Raw target information passed on the command line. newtype RawInput = RawInput { unRawInput :: Text } getRawInput :: BuildOptsCLI -> Map PackageName LocalPackageView -> ([Text], [RawInput]) getRawInput boptscli locals = let textTargets' = boptsCLITargets boptscli textTargets = -- Handle the no targets case, which means we pass in the names of all project packages if null textTargets' then map packageNameText (Map.keys locals) else textTargets' in (textTargets', map RawInput textTargets) --------------------------------------------------------------------------------- -- Turn RawInput into RawTarget --------------------------------------------------------------------------------- -- | The name of a component, which applies to executables, test -- suites, and benchmarks type ComponentName = Text -- | Either a fully resolved component, or a component name that could be -- either an executable, test, or benchmark data UnresolvedComponent = ResolvedComponent !NamedComponent | UnresolvedComponent !ComponentName deriving (Show, Eq, Ord) -- | Raw command line input, without checking against any databases or list of -- locals. Does not deal with directories data RawTarget = RTPackageComponent !PackageName !UnresolvedComponent | RTComponent !ComponentName | RTPackage !PackageName -- Explicitly _not_ supporting revisions on the command line. If -- you want that, you should be modifying your stack.yaml! (In -- fact, you should probably do that anyway, we're just letting -- people be lazy, since we're Haskeletors.) | RTPackageIdentifier !PackageIdentifier deriving (Show, Eq) -- | Same as @parseRawTarget@, but also takes directories into account. parseRawTargetDirs :: MonadIO m => Path Abs Dir -- ^ current directory -> Map PackageName LocalPackageView -> RawInput -- ^ raw target information from the commandline -> m (Either Text [(RawInput, RawTarget)]) parseRawTargetDirs root locals ri = case parseRawTarget t of Just rt -> return $ Right [(ri, rt)] Nothing -> do mdir <- liftIO $ forgivingAbsence (resolveDir root (T.unpack t)) >>= rejectMissingDir case mdir of Nothing -> return $ Left $ "Directory not found: " `T.append` t Just dir -> case mapMaybe (childOf dir) $ Map.toList locals of [] -> return $ Left $ "No local directories found as children of " `T.append` t names -> return $ Right $ map ((ri, ) . RTPackage) names where childOf dir (name, lpv) = if dir == lpvRoot lpv || isProperPrefixOf dir (lpvRoot lpv) then Just name else Nothing RawInput t = ri -- | If this function returns @Nothing@, the input should be treated as a -- directory. parseRawTarget :: Text -> Maybe RawTarget parseRawTarget t = (RTPackageIdentifier <$> parsePackageIdentifier t) <|> (RTPackage <$> parsePackageNameFromString s) <|> (RTComponent <$> T.stripPrefix ":" t) <|> parsePackageComponent where s = T.unpack t parsePackageComponent = case T.splitOn ":" t of [pname, "lib"] | Just pname' <- parsePackageNameFromString (T.unpack pname) -> Just $ RTPackageComponent pname' $ ResolvedComponent CLib [pname, cname] | Just pname' <- parsePackageNameFromString (T.unpack pname) -> Just $ RTPackageComponent pname' $ UnresolvedComponent cname [pname, typ, cname] | Just pname' <- parsePackageNameFromString (T.unpack pname) , Just wrapper <- parseCompType typ -> Just $ RTPackageComponent pname' $ ResolvedComponent $ wrapper cname _ -> Nothing parseCompType t' = case t' of "exe" -> Just CExe "test" -> Just CTest "bench" -> Just CBench _ -> Nothing --------------------------------------------------------------------------------- -- Resolve the raw targets --------------------------------------------------------------------------------- data ResolveResult = ResolveResult { rrName :: !PackageName , rrRaw :: !RawInput , rrComponent :: !(Maybe NamedComponent) -- ^ Was a concrete component specified? , rrAddedDep :: !(Maybe Version) -- ^ Only if we're adding this as a dependency , rrPackageType :: !PackageType } -- | Convert a 'RawTarget' into a 'ResolveResult' (see description on -- the module). resolveRawTarget :: forall env. HasConfig env => Map PackageName (LoadedPackageInfo GhcPkgId) -- ^ globals -> Map PackageName (LoadedPackageInfo (PackageLocationIndex FilePath)) -- ^ snapshot -> Map PackageName (GenericPackageDescription, PackageLocationIndex FilePath) -- ^ local deps -> Map PackageName LocalPackageView -- ^ project packages -> (RawInput, RawTarget) -> RIO env (Either Text ResolveResult) resolveRawTarget globals snap deps locals (ri, rt) = go rt where -- Helper function: check if a 'NamedComponent' matches the given 'ComponentName' isCompNamed :: ComponentName -> NamedComponent -> Bool isCompNamed _ CLib = False isCompNamed t1 (CInternalLib t2) = t1 == t2 isCompNamed t1 (CExe t2) = t1 == t2 isCompNamed t1 (CTest t2) = t1 == t2 isCompNamed t1 (CBench t2) = t1 == t2 go (RTComponent cname) = return $ -- Associated list from component name to package that defines -- it. We use an assoc list and not a Map so we can detect -- duplicates. let allPairs = concatMap (\(name, lpv) -> map (name,) $ Set.toList $ lpvComponents lpv) (Map.toList locals) in case filter (isCompNamed cname . snd) allPairs of [] -> Left $ cname `T.append` " doesn't seem to be a local target. Run 'stack ide targets' for a list of available targets" [(name, comp)] -> Right ResolveResult { rrName = name , rrRaw = ri , rrComponent = Just comp , rrAddedDep = Nothing , rrPackageType = ProjectPackage } matches -> Left $ T.concat [ "Ambiugous component name " , cname , ", matches: " , T.pack $ show matches ] go (RTPackageComponent name ucomp) = return $ case Map.lookup name locals of Nothing -> Left $ T.pack $ "Unknown local package: " ++ packageNameString name Just lpv -> case ucomp of ResolvedComponent comp | comp `Set.member` lpvComponents lpv -> Right ResolveResult { rrName = name , rrRaw = ri , rrComponent = Just comp , rrAddedDep = Nothing , rrPackageType = ProjectPackage } | otherwise -> Left $ T.pack $ concat [ "Component " , show comp , " does not exist in package " , packageNameString name ] UnresolvedComponent comp -> case filter (isCompNamed comp) $ Set.toList $ lpvComponents lpv of [] -> Left $ T.concat [ "Component " , comp , " does not exist in package " , T.pack $ packageNameString name ] [x] -> Right ResolveResult { rrName = name , rrRaw = ri , rrComponent = Just x , rrAddedDep = Nothing , rrPackageType = ProjectPackage } matches -> Left $ T.concat [ "Ambiguous component name " , comp , " for package " , T.pack $ packageNameString name , ": " , T.pack $ show matches ] go (RTPackage name) | Map.member name locals = return $ Right ResolveResult { rrName = name , rrRaw = ri , rrComponent = Nothing , rrAddedDep = Nothing , rrPackageType = ProjectPackage } | Map.member name deps || Map.member name snap || Map.member name globals = return $ Right ResolveResult { rrName = name , rrRaw = ri , rrComponent = Nothing , rrAddedDep = Nothing , rrPackageType = Dependency } | otherwise = do mversion <- getLatestVersion name return $ case mversion of -- This is actually an error case. We _could_ return a -- Left value here, but it turns out to be better to defer -- this until the ConstructPlan phase, and let it complain -- about the missing package so that we get more errors -- together, plus the fancy colored output from that -- module. Nothing -> Right ResolveResult { rrName = name , rrRaw = ri , rrComponent = Nothing , rrAddedDep = Nothing , rrPackageType = Dependency } Just version -> Right ResolveResult { rrName = name , rrRaw = ri , rrComponent = Nothing , rrAddedDep = Just version , rrPackageType = Dependency } where getLatestVersion pn = fmap fst . Set.maxView . Set.fromList . HashMap.keys <$> getPackageVersions pn go (RTPackageIdentifier ident@(PackageIdentifier name version)) | Map.member name locals = return $ Left $ T.concat [ packageNameText name , " target has a specific version number, but it is a local package." , "\nTo avoid confusion, we will not install the specified version or build the local one." , "\nTo build the local package, specify the target without an explicit version." ] | otherwise = return $ case Map.lookup name allLocs of -- Installing it from the package index, so we're cool -- with overriding it if necessary Just (PLIndex (PackageIdentifierRevision (PackageIdentifier _name versionLoc) _mcfi)) -> Right ResolveResult { rrName = name , rrRaw = ri , rrComponent = Nothing , rrAddedDep = if version == versionLoc -- But no need to override anyway, this is already the -- version we have then Nothing -- OK, we'll override it else Just version , rrPackageType = Dependency } -- The package was coming from something besides the -- index, so refuse to do the override Just (PLOther loc') -> Left $ T.concat [ "Package with identifier was targeted on the command line: " , packageIdentifierText ident , ", but it was specified from a non-index location: " , T.pack $ show loc' , ".\nRecommendation: add the correctly desired version to extra-deps." ] -- Not present at all, so add it Nothing -> Right ResolveResult { rrName = name , rrRaw = ri , rrComponent = Nothing , rrAddedDep = Just version , rrPackageType = Dependency } where allLocs :: Map PackageName (PackageLocationIndex FilePath) allLocs = Map.unions [ Map.mapWithKey (\name' lpi -> PLIndex $ PackageIdentifierRevision (PackageIdentifier name' (lpiVersion lpi)) CFILatest) globals , Map.map lpiLocation snap , Map.map snd deps ] --------------------------------------------------------------------------------- -- Combine the ResolveResults --------------------------------------------------------------------------------- -- | How a package is intended to be built data Target = TargetAll !PackageType -- ^ Build all of the default components. | TargetComps !(Set NamedComponent) -- ^ Only build specific components data PackageType = ProjectPackage | Dependency deriving (Eq, Show) combineResolveResults :: forall env. HasLogFunc env => [ResolveResult] -> RIO env ([Text], Map PackageName Target, Map PackageName (PackageLocationIndex FilePath)) combineResolveResults results = do addedDeps <- fmap Map.unions $ forM results $ \result -> case rrAddedDep result of Nothing -> return Map.empty Just version -> do let ident = PackageIdentifier (rrName result) version return $ Map.singleton (rrName result) $ PLIndex $ PackageIdentifierRevision ident CFILatest let m0 = Map.unionsWith (++) $ map (\rr -> Map.singleton (rrName rr) [rr]) results (errs, ms) = partitionEithers $ flip map (Map.toList m0) $ \(name, rrs) -> let mcomps = map rrComponent rrs in -- Confirm that there is either exactly 1 with no component, or -- that all rrs are components case rrs of [] -> assert False $ Left "Somehow got no rrComponent values, that can't happen" [rr] | isNothing (rrComponent rr) -> Right $ Map.singleton name $ TargetAll $ rrPackageType rr _ | all isJust mcomps -> Right $ Map.singleton name $ TargetComps $ Set.fromList $ catMaybes mcomps | otherwise -> Left $ T.concat [ "The package " , packageNameText name , " was specified in multiple, incompatible ways: " , T.unwords $ map (unRawInput . rrRaw) rrs ] return (errs, Map.unions ms, addedDeps) --------------------------------------------------------------------------------- -- OK, let's do it! --------------------------------------------------------------------------------- parseTargets :: HasEnvConfig env => NeedTargets -> BuildOptsCLI -> RIO env ( LoadedSnapshot -- upgraded snapshot, with some packages possibly moved to local , Map PackageName (LoadedPackageInfo (PackageLocationIndex FilePath)) -- all local deps , Map PackageName Target ) parseTargets needTargets boptscli = do logDebug "Parsing the targets" bconfig <- view buildConfigL ls0 <- view loadedSnapshotL workingDir <- getCurrentDir lp <- getLocalPackages let locals = lpProject lp deps = lpDependencies lp globals = lsGlobals ls0 snap = lsPackages ls0 (textTargets', rawInput) = getRawInput boptscli locals (errs1, concat -> rawTargets) <- fmap partitionEithers $ forM rawInput $ parseRawTargetDirs workingDir (lpProject lp) (errs2, resolveResults) <- fmap partitionEithers $ forM rawTargets $ resolveRawTarget globals snap deps locals (errs3, targets, addedDeps) <- combineResolveResults resolveResults case concat [errs1, errs2, errs3] of [] -> return () errs -> throwIO $ TargetParseException errs case (Map.null targets, needTargets) of (False, _) -> return () (True, AllowNoTargets) -> return () (True, NeedTargets) | null textTargets' && bcImplicitGlobal bconfig -> throwIO $ TargetParseException ["The specified targets matched no packages.\nPerhaps you need to run 'stack init'?"] | null textTargets' && Map.null locals -> throwIO $ TargetParseException ["The project contains no local packages (packages not marked with 'extra-dep')"] | otherwise -> throwIO $ TargetParseException ["The specified targets matched no packages"] root <- view projectRootL let dropMaybeKey (Nothing, _) = Map.empty dropMaybeKey (Just key, value) = Map.singleton key value flags = Map.unionWith Map.union (Map.unions (map dropMaybeKey (Map.toList (boptsCLIFlags boptscli)))) (bcFlags bconfig) hides = Map.empty -- not supported to add hidden packages -- We promote packages to the local database if the GHC options -- are added to them by name. See: -- https://github.com/commercialhaskell/stack/issues/849#issuecomment-320892095. -- -- GHC options applied to all packages are handled by getGhcOptions. options = configGhcOptionsByName (bcConfig bconfig) drops = Set.empty -- not supported to add drops (globals', snapshots, locals') <- do addedDeps' <- fmap Map.fromList $ forM (Map.toList addedDeps) $ \(name, loc) -> do gpd <- parseSingleCabalFileIndex root loc return (name, (gpd, loc, Nothing)) -- Calculate a list of all of the locals, based on the project -- packages, local dependencies, and added deps found from the -- command line let allLocals :: Map PackageName (GenericPackageDescription, PackageLocationIndex FilePath, Maybe LocalPackageView) allLocals = Map.unions [ -- project packages Map.map (\lpv -> (lpvGPD lpv, PLOther $ lpvLoc lpv, Just lpv)) (lpProject lp) , -- added deps take precendence over local deps addedDeps' , -- added deps take precendence over local deps Map.map (\(gpd, loc) -> (gpd, loc, Nothing)) (lpDependencies lp) ] calculatePackagePromotion root ls0 (Map.elems allLocals) flags hides options drops let ls = LoadedSnapshot { lsCompilerVersion = lsCompilerVersion ls0 , lsGlobals = globals' , lsPackages = snapshots } localDeps = Map.fromList $ flip mapMaybe (Map.toList locals') $ \(name, lpi) -> -- We want to ignore any project packages, but grab the local -- deps and upgraded snapshot deps case lpiLocation lpi of (_, Just (Just _localPackageView)) -> Nothing -- project package (loc, _) -> Just (name, lpi { lpiLocation = loc }) -- upgraded or local dep return (ls, localDeps, targets) gpdVersion :: GenericPackageDescription -> Version gpdVersion gpd = version where PackageIdentifier _ version = fromCabalPackageIdentifier $ package $ packageDescription gpd stack-1.9.3.1/src/Stack/BuildPlan.hs0000644000000000000000000004746013455617610015243 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude #-} {-# LANGUAGE ConstraintKinds #-} {-# LANGUAGE DataKinds #-} {-# LANGUAGE DeriveDataTypeable #-} {-# LANGUAGE FlexibleContexts #-} {-# LANGUAGE GADTs #-} {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE ScopedTypeVariables #-} -- | Resolving a build plan for a set of packages in a given Stackage -- snapshot. module Stack.BuildPlan ( BuildPlanException (..) , BuildPlanCheck (..) , checkSnapBuildPlan , DepError(..) , DepErrors , gpdPackageDeps , gpdPackages , removeSrcPkgDefaultFlags , selectBestSnapshot , showItems ) where import Stack.Prelude hiding (Display (..)) import qualified Data.Foldable as F import qualified Data.HashSet as HashSet import Data.List (intercalate) import Data.List.NonEmpty (NonEmpty(..)) import qualified Data.List.NonEmpty as NonEmpty import qualified Data.Map as Map import qualified Data.Set as Set import qualified Data.Text as T import qualified Distribution.Package as C import Distribution.PackageDescription (GenericPackageDescription, flagDefault, flagManual, flagName, genPackageFlags) import qualified Distribution.PackageDescription as C import Distribution.System (Platform) import Distribution.Text (display) import qualified Distribution.Version as C import qualified RIO import Stack.Constants import Stack.Package import Stack.Snapshot import Stack.Types.BuildPlan import Stack.Types.FlagName import Stack.Types.PackageIdentifier import Stack.Types.PackageName import Stack.Types.Version import Stack.Types.Config import Stack.Types.Compiler import Stack.Types.Resolver data BuildPlanException = UnknownPackages (Path Abs File) -- stack.yaml file (Map PackageName (Maybe Version, Set PackageName)) -- truly unknown (Map PackageName (Set PackageIdentifier)) -- shadowed | SnapshotNotFound SnapName | NeitherCompilerOrResolverSpecified T.Text deriving (Typeable) instance Exception BuildPlanException instance Show BuildPlanException where show (SnapshotNotFound snapName) = unlines [ "SnapshotNotFound " ++ snapName' , "Non existing resolver: " ++ snapName' ++ "." , "For a complete list of available snapshots see https://www.stackage.org/snapshots" ] where snapName' = show $ renderSnapName snapName show (UnknownPackages stackYaml unknown shadowed) = unlines $ unknown' ++ shadowed' where unknown' :: [String] unknown' | Map.null unknown = [] | otherwise = concat [ ["The following packages do not exist in the build plan:"] , map go (Map.toList unknown) , case mapMaybe goRecommend $ Map.toList unknown of [] -> [] rec -> ("Recommended action: modify the extra-deps field of " ++ toFilePath stackYaml ++ " to include the following:") : (rec ++ ["Note: further dependencies may need to be added"]) , case mapMaybe getNoKnown $ Map.toList unknown of [] -> [] noKnown -> [ "There are no known versions of the following packages:" , intercalate ", " $ map packageNameString noKnown ] ] where go (dep, (_, users)) | Set.null users = packageNameString dep go (dep, (_, users)) = concat [ packageNameString dep , " (used by " , intercalate ", " $ map packageNameString $ Set.toList users , ")" ] goRecommend (name, (Just version, _)) = Just $ "- " ++ packageIdentifierString (PackageIdentifier name version) goRecommend (_, (Nothing, _)) = Nothing getNoKnown (name, (Nothing, _)) = Just name getNoKnown (_, (Just _, _)) = Nothing shadowed' :: [String] shadowed' | Map.null shadowed = [] | otherwise = concat [ ["The following packages are shadowed by local packages:"] , map go (Map.toList shadowed) , ["Recommended action: modify the extra-deps field of " ++ toFilePath stackYaml ++ " to include the following:"] , extraDeps , ["Note: further dependencies may need to be added"] ] where go (dep, users) | Set.null users = packageNameString dep ++ " (internal stack error: this should never be null)" go (dep, users) = concat [ packageNameString dep , " (used by " , intercalate ", " $ map (packageNameString . packageIdentifierName) $ Set.toList users , ")" ] extraDeps = map (\ident -> "- " ++ packageIdentifierString ident) $ Set.toList $ Set.unions $ Map.elems shadowed show (NeitherCompilerOrResolverSpecified url) = "Failed to load custom snapshot at " ++ T.unpack url ++ ", because no 'compiler' or 'resolver' is specified." gpdPackages :: [GenericPackageDescription] -> Map PackageName Version gpdPackages gpds = Map.fromList $ map (fromCabalIdent . C.package . C.packageDescription) gpds where fromCabalIdent (C.PackageIdentifier name version) = (fromCabalPackageName name, fromCabalVersion version) gpdPackageDeps :: GenericPackageDescription -> CompilerVersion 'CVActual -> Platform -> Map FlagName Bool -> Map PackageName VersionRange gpdPackageDeps gpd cv platform flags = Map.filterWithKey (const . (/= name)) (packageDependencies pkgConfig pkgDesc) where name = gpdPackageName gpd -- Since tests and benchmarks are both enabled, doesn't matter -- if we choose modified or unmodified pkgDesc = pdpModifiedBuildable $ resolvePackageDescription pkgConfig gpd pkgConfig = PackageConfig { packageConfigEnableTests = True , packageConfigEnableBenchmarks = True , packageConfigFlags = flags , packageConfigGhcOptions = [] , packageConfigCompilerVersion = cv , packageConfigPlatform = platform } -- Remove any src package flags having default values -- Remove any package entries with no flags set removeSrcPkgDefaultFlags :: [C.GenericPackageDescription] -> Map PackageName (Map FlagName Bool) -> Map PackageName (Map FlagName Bool) removeSrcPkgDefaultFlags gpds flags = let defaults = Map.unions (map gpdDefaultFlags gpds) flags' = Map.differenceWith removeSame flags defaults in Map.filter (not . Map.null) flags' where removeSame f1 f2 = let diff v v' = if v == v' then Nothing else Just v in Just $ Map.differenceWith diff f1 f2 gpdDefaultFlags gpd = let tuples = map getDefault (C.genPackageFlags gpd) in Map.singleton (gpdPackageName gpd) (Map.fromList tuples) flagName' = fromCabalFlagName . C.flagName getDefault f | C.flagDefault f = (flagName' f, True) | otherwise = (flagName' f, False) -- | Find the set of @FlagName@s necessary to get the given -- @GenericPackageDescription@ to compile against the given @BuildPlan@. Will -- only modify non-manual flags, and will prefer default values for flags. -- Returns the plan which produces least number of dep errors selectPackageBuildPlan :: Platform -> CompilerVersion 'CVActual -> Map PackageName Version -> GenericPackageDescription -> (Map PackageName (Map FlagName Bool), DepErrors) selectPackageBuildPlan platform compiler pool gpd = (selectPlan . limitSearchSpace . NonEmpty.map makePlan) flagCombinations where selectPlan :: NonEmpty (a, DepErrors) -> (a, DepErrors) selectPlan = F.foldr1 fewerErrors where fewerErrors p1 p2 | nErrors p1 == 0 = p1 | nErrors p1 <= nErrors p2 = p1 | otherwise = p2 where nErrors = Map.size . snd -- Avoid exponential complexity in flag combinations making us sad pandas. -- See: https://github.com/commercialhaskell/stack/issues/543 limitSearchSpace :: NonEmpty a -> NonEmpty a limitSearchSpace (x :| xs) = x :| take (maxFlagCombinations - 1) xs where maxFlagCombinations = 128 makePlan :: [(FlagName, Bool)] -> (Map PackageName (Map FlagName Bool), DepErrors) makePlan flags = checkPackageBuildPlan platform compiler pool (Map.fromList flags) gpd flagCombinations :: NonEmpty [(FlagName, Bool)] flagCombinations = mapM getOptions (genPackageFlags gpd) where getOptions :: C.Flag -> NonEmpty (FlagName, Bool) getOptions f | flagManual f = (fname, flagDefault f) :| [] | flagDefault f = (fname, True) :| [(fname, False)] | otherwise = (fname, False) :| [(fname, True)] where fname = (fromCabalFlagName . flagName) f -- | Check whether with the given set of flags a package's dependency -- constraints can be satisfied against a given build plan or pool of packages. checkPackageBuildPlan :: Platform -> CompilerVersion 'CVActual -> Map PackageName Version -> Map FlagName Bool -> GenericPackageDescription -> (Map PackageName (Map FlagName Bool), DepErrors) checkPackageBuildPlan platform compiler pool flags gpd = (Map.singleton pkg flags, errs) where pkg = gpdPackageName gpd errs = checkPackageDeps pkg constraints pool constraints = gpdPackageDeps gpd compiler platform flags -- | Checks if the given package dependencies can be satisfied by the given set -- of packages. Will fail if a package is either missing or has a version -- outside of the version range. checkPackageDeps :: PackageName -- ^ package using dependencies, for constructing DepErrors -> Map PackageName VersionRange -- ^ dependency constraints -> Map PackageName Version -- ^ Available package pool or index -> DepErrors checkPackageDeps myName deps packages = Map.unionsWith combineDepError $ map go $ Map.toList deps where go :: (PackageName, VersionRange) -> DepErrors go (name, range) = case Map.lookup name packages of Nothing -> Map.singleton name DepError { deVersion = Nothing , deNeededBy = Map.singleton myName range } Just v | withinRange v range -> Map.empty | otherwise -> Map.singleton name DepError { deVersion = Just v , deNeededBy = Map.singleton myName range } type DepErrors = Map PackageName DepError data DepError = DepError { deVersion :: !(Maybe Version) , deNeededBy :: !(Map PackageName VersionRange) } deriving Show -- | Combine two 'DepError's for the same 'Version'. combineDepError :: DepError -> DepError -> DepError combineDepError (DepError a x) (DepError b y) = assert (a == b) $ DepError a (Map.unionWith C.intersectVersionRanges x y) -- | Given a bundle of packages (a list of @GenericPackageDescriptions@'s) to -- build and an available package pool (snapshot) check whether the bundle's -- dependencies can be satisfied. If flags is passed as Nothing flag settings -- will be chosen automatically. checkBundleBuildPlan :: Platform -> CompilerVersion 'CVActual -> Map PackageName Version -> Maybe (Map PackageName (Map FlagName Bool)) -> [GenericPackageDescription] -> (Map PackageName (Map FlagName Bool), DepErrors) checkBundleBuildPlan platform compiler pool flags gpds = (Map.unionsWith dupError (map fst plans) , Map.unionsWith combineDepError (map snd plans)) where plans = map (pkgPlan flags) gpds pkgPlan Nothing gpd = selectPackageBuildPlan platform compiler pool' gpd pkgPlan (Just f) gpd = checkPackageBuildPlan platform compiler pool' (flags' f gpd) gpd flags' f gpd = fromMaybe Map.empty (Map.lookup (gpdPackageName gpd) f) pool' = Map.union (gpdPackages gpds) pool dupError _ _ = error "Bug: Duplicate packages are not expected here" data BuildPlanCheck = BuildPlanCheckOk (Map PackageName (Map FlagName Bool)) | BuildPlanCheckPartial (Map PackageName (Map FlagName Bool)) DepErrors | BuildPlanCheckFail (Map PackageName (Map FlagName Bool)) DepErrors (CompilerVersion 'CVActual) -- | Compare 'BuildPlanCheck', where GT means a better plan. compareBuildPlanCheck :: BuildPlanCheck -> BuildPlanCheck -> Ordering compareBuildPlanCheck (BuildPlanCheckPartial _ e1) (BuildPlanCheckPartial _ e2) = -- Note: order of comparison flipped, since it's better to have fewer errors. compare (Map.size e2) (Map.size e1) compareBuildPlanCheck (BuildPlanCheckFail _ e1 _) (BuildPlanCheckFail _ e2 _) = let numUserPkgs e = Map.size $ Map.unions (Map.elems (fmap deNeededBy e)) in compare (numUserPkgs e2) (numUserPkgs e1) compareBuildPlanCheck BuildPlanCheckOk{} BuildPlanCheckOk{} = EQ compareBuildPlanCheck BuildPlanCheckOk{} BuildPlanCheckPartial{} = GT compareBuildPlanCheck BuildPlanCheckOk{} BuildPlanCheckFail{} = GT compareBuildPlanCheck BuildPlanCheckPartial{} BuildPlanCheckFail{} = GT compareBuildPlanCheck _ _ = LT instance Show BuildPlanCheck where show BuildPlanCheckOk {} = "" show (BuildPlanCheckPartial f e) = T.unpack $ showDepErrors f e show (BuildPlanCheckFail f e c) = T.unpack $ showCompilerErrors f e c -- | Check a set of 'GenericPackageDescription's and a set of flags against a -- given snapshot. Returns how well the snapshot satisfies the dependencies of -- the packages. checkSnapBuildPlan :: (HasConfig env, HasGHCVariant env) => Path Abs Dir -- ^ project root, used for checking out necessary files -> [GenericPackageDescription] -> Maybe (Map PackageName (Map FlagName Bool)) -> SnapshotDef -> Maybe (CompilerVersion 'CVActual) -> RIO env BuildPlanCheck checkSnapBuildPlan root gpds flags snapshotDef mactualCompiler = do platform <- view platformL rs <- loadSnapshot mactualCompiler root snapshotDef let compiler = lsCompilerVersion rs snapPkgs = Map.union (lpiVersion <$> lsGlobals rs) (lpiVersion <$> lsPackages rs) (f, errs) = checkBundleBuildPlan platform compiler snapPkgs flags gpds cerrs = compilerErrors compiler errs if Map.null errs then return $ BuildPlanCheckOk f else if Map.null cerrs then do return $ BuildPlanCheckPartial f errs else return $ BuildPlanCheckFail f cerrs compiler where compilerErrors compiler errs | whichCompiler compiler == Ghc = ghcErrors errs -- FIXME not sure how to handle ghcjs boot packages | otherwise = Map.empty isGhcWiredIn p _ = p `HashSet.member` wiredInPackages ghcErrors = Map.filterWithKey isGhcWiredIn -- | Find a snapshot and set of flags that is compatible with and matches as -- best as possible with the given 'GenericPackageDescription's. selectBestSnapshot :: (HasConfig env, HasGHCVariant env) => Path Abs Dir -- ^ project root, used for checking out necessary files -> [GenericPackageDescription] -> NonEmpty SnapName -> RIO env (SnapshotDef, BuildPlanCheck) selectBestSnapshot root gpds snaps = do logInfo $ "Selecting the best among " <> displayShow (NonEmpty.length snaps) <> " snapshots...\n" F.foldr1 go (NonEmpty.map (getResult <=< loadResolver . ResolverStackage) snaps) where go mold mnew = do old@(_snap, bpc) <- mold case bpc of BuildPlanCheckOk {} -> return old _ -> fmap (betterSnap old) mnew getResult snap = do result <- checkSnapBuildPlan root gpds Nothing snap -- We know that we're only dealing with ResolverStackage -- here, where we can rely on the global package hints. -- Therefore, we don't use an actual compiler. For more -- info, see comments on -- Stack.Solver.checkSnapBuildPlanActual. Nothing reportResult result snap return (snap, result) betterSnap (s1, r1) (s2, r2) | compareBuildPlanCheck r1 r2 /= LT = (s1, r1) | otherwise = (s2, r2) reportResult BuildPlanCheckOk {} snap = do logInfo $ "* Matches " <> RIO.display (sdResolverName snap) logInfo "" reportResult r@BuildPlanCheckPartial {} snap = do logWarn $ "* Partially matches " <> RIO.display (sdResolverName snap) logWarn $ RIO.display $ indent $ T.pack $ show r reportResult r@BuildPlanCheckFail {} snap = do logWarn $ "* Rejected " <> RIO.display (sdResolverName snap) logWarn $ RIO.display $ indent $ T.pack $ show r indent t = T.unlines $ fmap (" " <>) (T.lines t) showItems :: Show a => [a] -> Text showItems items = T.concat (map formatItem items) where formatItem item = T.concat [ " - " , T.pack $ show item , "\n" ] showPackageFlags :: PackageName -> Map FlagName Bool -> Text showPackageFlags pkg fl = if not $ Map.null fl then T.concat [ " - " , T.pack $ packageNameString pkg , ": " , T.pack $ intercalate ", " $ map formatFlags (Map.toList fl) , "\n" ] else "" where formatFlags (f, v) = show f ++ " = " ++ show v showMapPackages :: Map PackageName a -> Text showMapPackages mp = showItems $ Map.keys mp showCompilerErrors :: Map PackageName (Map FlagName Bool) -> DepErrors -> CompilerVersion 'CVActual -> Text showCompilerErrors flags errs compiler = T.concat [ compilerVersionText compiler , " cannot be used for these packages:\n" , showMapPackages $ Map.unions (Map.elems (fmap deNeededBy errs)) , showDepErrors flags errs -- TODO only in debug mode ] showDepErrors :: Map PackageName (Map FlagName Bool) -> DepErrors -> Text showDepErrors flags errs = T.concat [ T.concat $ map formatError (Map.toList errs) , if T.null flagVals then "" else "Using package flags:\n" <> flagVals ] where formatError (depName, DepError mversion neededBy) = T.concat [ showDepVersion depName mversion , T.concat (map showRequirement (Map.toList neededBy)) ] showDepVersion depName mversion = T.concat [ T.pack $ packageNameString depName , case mversion of Nothing -> " not found" Just version -> T.concat [ " version " , T.pack $ versionString version , " found" ] , "\n" ] showRequirement (user, range) = T.concat [ " - " , T.pack $ packageNameString user , " requires " , T.pack $ display range , "\n" ] flagVals = T.concat (map showFlags userPkgs) userPkgs = Map.keys $ Map.unions (Map.elems (fmap deNeededBy errs)) showFlags pkg = maybe "" (showPackageFlags pkg) (Map.lookup pkg flags) stack-1.9.3.1/src/Stack/Clean.hs0000644000000000000000000000560113455671116014403 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude #-} {-# LANGUAGE ConstraintKinds #-} {-# LANGUAGE DeriveDataTypeable #-} {-# LANGUAGE FlexibleContexts #-} {-# LANGUAGE OverloadedStrings #-} -- | Clean a project. module Stack.Clean (clean ,CleanOpts(..) ,StackCleanException(..) ) where import Stack.Prelude import Data.List ((\\),intercalate) import qualified Data.Map.Strict as Map import Path.IO (ignoringAbsence, removeDirRecur) import Stack.Config (getLocalPackages) import Stack.Constants.Config (distDirFromDir, workDirFromDir) import Stack.Types.PackageName import Stack.Types.Config import System.Exit (exitFailure) -- | Deletes build artifacts in the current project. -- -- Throws 'StackCleanException'. clean :: HasEnvConfig env => CleanOpts -> RIO env () clean cleanOpts = do failures <- mapM cleanDir =<< dirsToDelete cleanOpts when (or failures) $ liftIO System.Exit.exitFailure where cleanDir dir = liftIO (ignoringAbsence (removeDirRecur dir) >> return False) `catchAny` \ex -> do logError $ "Exception while recursively deleting " <> fromString (toFilePath dir) <> "\n" <> displayShow ex logError "Perhaps you do not have permission to delete these files or they are in use?" return True dirsToDelete :: HasEnvConfig env => CleanOpts -> RIO env [Path Abs Dir] dirsToDelete cleanOpts = do packages <- getLocalPackages case cleanOpts of CleanShallow [] -> -- Filter out packages listed as extra-deps mapM (distDirFromDir . lpvRoot) $ Map.elems $ lpProject packages CleanShallow targets -> do let localPkgViews = lpProject packages localPkgNames = Map.keys localPkgViews getPkgDir pkgName = fmap lpvRoot (Map.lookup pkgName localPkgViews) case targets \\ localPkgNames of [] -> mapM distDirFromDir (mapMaybe getPkgDir targets) xs -> throwM (NonLocalPackages xs) CleanFull -> do pkgWorkDirs <- mapM (workDirFromDir . lpvRoot) $ Map.elems $ lpProject packages projectWorkDir <- getProjectWorkDir return (projectWorkDir : pkgWorkDirs) -- | Options for @stack clean@. data CleanOpts = CleanShallow [PackageName] -- ^ Delete the "dist directories" as defined in 'Stack.Constants.distRelativeDir' -- for the given local packages. If no packages are given, all project packages -- should be cleaned. | CleanFull -- ^ Delete all work directories in the project. -- | Exceptions during cleanup. newtype StackCleanException = NonLocalPackages [PackageName] deriving (Typeable) instance Show StackCleanException where show (NonLocalPackages pkgs) = "The following packages are not part of this project: " ++ intercalate ", " (map show pkgs) instance Exception StackCleanException stack-1.9.3.1/src/Stack/Config.hs0000644000000000000000000012250213455617610014565 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude #-} {-# LANGUAGE ConstraintKinds #-} {-# LANGUAGE CPP #-} {-# LANGUAGE DataKinds #-} {-# LANGUAGE DeriveFoldable #-} {-# LANGUAGE DeriveFunctor #-} {-# LANGUAGE DeriveTraversable #-} {-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE GeneralizedNewtypeDeriving #-} {-# LANGUAGE TemplateHaskell #-} {-# LANGUAGE FlexibleContexts #-} {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE RecordWildCards #-} {-# LANGUAGE DeriveDataTypeable #-} {-# LANGUAGE TypeFamilies #-} {-# LANGUAGE LambdaCase #-} {-# LANGUAGE ViewPatterns #-} {-# LANGUAGE TupleSections #-} -- | The general Stack configuration that starts everything off. This should -- be smart to falback if there is no stack.yaml, instead relying on -- whatever files are available. -- -- If there is no stack.yaml, and there is a cabal.config, we -- read in those constraints, and if there's a cabal.sandbox.config, -- we read any constraints from there and also find the package -- database from there, etc. And if there's nothing, we should -- probably default to behaving like cabal, possibly with spitting out -- a warning that "you should run `stk init` to make things better". module Stack.Config (MiniConfig ,loadConfig ,loadConfigMaybeProject ,loadMiniConfig ,loadConfigYaml ,packagesParser ,getLocalPackages ,getImplicitGlobalProjectDir ,getStackYaml ,getSnapshots ,makeConcreteResolver ,checkOwnership ,getInContainer ,getInNixShell ,defaultConfigYaml ,getProjectConfig ,LocalConfigStatus(..) ) where import Control.Monad.Extra (firstJustM) import Stack.Prelude import Data.Aeson.Extended import qualified Data.ByteString as S import Data.Coerce (coerce) import qualified Data.IntMap as IntMap import qualified Data.Map as Map import qualified Data.Monoid import Data.Monoid.Map (MonoidMap(..)) import qualified Data.Text as T import Data.Text.Encoding (encodeUtf8) import qualified Data.Yaml as Yaml import qualified Distribution.PackageDescription as C import Distribution.System (OS (..), Platform (..), buildPlatform, Arch(OtherArch)) import qualified Distribution.Text import Distribution.Version (simplifyVersionRange, mkVersion') import GHC.Conc (getNumProcessors) import Lens.Micro (lens, set) import Network.HTTP.StackClient (httpJSON, parseUrlThrow, getResponseBody) import Options.Applicative (Parser, strOption, long, help) import Path import Path.Extra (toFilePathNoTrailingSep) import Path.Find (findInParents) import Path.IO import qualified Paths_stack as Meta import Stack.Config.Build import Stack.Config.Docker import Stack.Config.Nix import Stack.Config.Urls import Stack.Constants import qualified Stack.Image as Image import Stack.PackageLocation import Stack.PackageIndex (CabalLoader (..), HasCabalLoader (..)) import Stack.Snapshot import Stack.Types.BuildPlan import Stack.Types.Compiler import Stack.Types.Config import Stack.Types.Docker import Stack.Types.Nix import Stack.Types.PackageName (PackageName) import Stack.Types.PackageIdentifier import Stack.Types.PackageIndex (IndexType (ITHackageSecurity), HackageSecurity (..)) import Stack.Types.Resolver import Stack.Types.Runner import Stack.Types.Urls import Stack.Types.Version import System.Environment import System.PosixCompat.Files (fileOwner, getFileStatus) import System.PosixCompat.User (getEffectiveUserID) import RIO.Process -- | If deprecated path exists, use it and print a warning. -- Otherwise, return the new path. tryDeprecatedPath :: HasLogFunc env => Maybe T.Text -- ^ Description of file for warning (if Nothing, no deprecation warning is displayed) -> (Path Abs a -> RIO env Bool) -- ^ Test for existence -> Path Abs a -- ^ New path -> Path Abs a -- ^ Deprecated path -> RIO env (Path Abs a, Bool) -- ^ (Path to use, whether it already exists) tryDeprecatedPath mWarningDesc exists new old = do newExists <- exists new if newExists then return (new, True) else do oldExists <- exists old if oldExists then do case mWarningDesc of Nothing -> return () Just desc -> logWarn $ "Warning: Location of " <> display desc <> " at '" <> fromString (toFilePath old) <> "' is deprecated; rename it to '" <> fromString (toFilePath new) <> "' instead" return (old, True) else return (new, False) -- | Get the location of the implicit global project directory. -- If the directory already exists at the deprecated location, its location is returned. -- Otherwise, the new location is returned. getImplicitGlobalProjectDir :: HasLogFunc env => Config -> RIO env (Path Abs Dir) getImplicitGlobalProjectDir config = --TEST no warning printed liftM fst $ tryDeprecatedPath Nothing doesDirExist (implicitGlobalProjectDir stackRoot) (implicitGlobalProjectDirDeprecated stackRoot) where stackRoot = view stackRootL config -- | This is slightly more expensive than @'asks' ('bcStackYaml' '.' 'getBuildConfig')@ -- and should only be used when no 'BuildConfig' is at hand. getStackYaml :: HasConfig env => RIO env (Path Abs File) getStackYaml = do config <- view configL case configMaybeProject config of Just (_project, stackYaml) -> return stackYaml Nothing -> liftM ( stackDotYaml) (getImplicitGlobalProjectDir config) -- | Download the 'Snapshots' value from stackage.org. getSnapshots :: HasConfig env => RIO env Snapshots getSnapshots = do latestUrlText <- askLatestSnapshotUrl latestUrl <- parseUrlThrow (T.unpack latestUrlText) logDebug $ "Downloading snapshot versions file from " <> display latestUrlText result <- httpJSON latestUrl logDebug "Done downloading and parsing snapshot versions file" return $ getResponseBody result -- | Turn an 'AbstractResolver' into a 'Resolver'. makeConcreteResolver :: HasConfig env => Maybe (Path Abs Dir) -- ^ root of project for resolving custom relative paths -> AbstractResolver -> RIO env Resolver makeConcreteResolver root (ARResolver r) = parseCustomLocation root r makeConcreteResolver root ar = do snapshots <- getSnapshots r <- case ar of ARResolver r -> assert False $ makeConcreteResolver root $ ARResolver r ARGlobal -> do config <- view configL implicitGlobalDir <- getImplicitGlobalProjectDir config let fp = implicitGlobalDir stackDotYaml ProjectAndConfigMonoid project _ <- loadConfigYaml (parseProjectAndConfigMonoid (parent fp)) fp return $ projectResolver project ARLatestNightly -> return $ ResolverStackage $ Nightly $ snapshotsNightly snapshots ARLatestLTSMajor x -> case IntMap.lookup x $ snapshotsLts snapshots of Nothing -> throwString $ "No LTS release found with major version " ++ show x Just y -> return $ ResolverStackage $ LTS x y ARLatestLTS | IntMap.null $ snapshotsLts snapshots -> throwString "No LTS releases found" | otherwise -> let (x, y) = IntMap.findMax $ snapshotsLts snapshots in return $ ResolverStackage $ LTS x y logInfo $ "Selected resolver: " <> display (resolverRawName r) return r -- | Get the latest snapshot resolver available. getLatestResolver :: HasConfig env => RIO env (ResolverWith a) getLatestResolver = do snapshots <- getSnapshots let mlts = do (x,y) <- listToMaybe (reverse (IntMap.toList (snapshotsLts snapshots))) return (LTS x y) snap = fromMaybe (Nightly (snapshotsNightly snapshots)) mlts return (ResolverStackage snap) -- | Create a 'Config' value when we're not using any local -- configuration files (e.g., the script command) configNoLocalConfig :: HasRunner env => Path Abs Dir -- ^ stack root -> Maybe AbstractResolver -> ConfigMonoid -> RIO env Config configNoLocalConfig _ Nothing _ = throwIO NoResolverWhenUsingNoLocalConfig configNoLocalConfig stackRoot (Just resolver) configMonoid = do userConfigPath <- liftIO $ getFakeConfigPath stackRoot resolver configFromConfigMonoid stackRoot userConfigPath False (Just resolver) Nothing -- project configMonoid -- Interprets ConfigMonoid options. configFromConfigMonoid :: HasRunner env => Path Abs Dir -- ^ stack root, e.g. ~/.stack -> Path Abs File -- ^ user config file path, e.g. ~/.stack/config.yaml -> Bool -- ^ allow locals? -> Maybe AbstractResolver -> Maybe (Project, Path Abs File) -> ConfigMonoid -> RIO env Config configFromConfigMonoid clStackRoot configUserConfigPath configAllowLocals mresolver mproject ConfigMonoid{..} = do -- If --stack-work is passed, prefer it. Otherwise, if STACK_WORK -- is set, use that. If neither, use the default ".stack-work" mstackWorkEnv <- liftIO $ lookupEnv stackWorkEnvVar configWorkDir0 <- maybe (return $(mkRelDir ".stack-work")) (liftIO . parseRelDir) mstackWorkEnv let configWorkDir = fromFirst configWorkDir0 configMonoidWorkDir -- This code is to handle the deprecation of latest-snapshot-url configUrls <- case (getFirst configMonoidLatestSnapshotUrl, getFirst (urlsMonoidLatestSnapshot configMonoidUrls)) of (Just url, Nothing) -> do logWarn "The latest-snapshot-url field is deprecated in favor of 'urls' configuration" return (urlsFromMonoid configMonoidUrls) { urlsLatestSnapshot = url } _ -> return (urlsFromMonoid configMonoidUrls) let clConnectionCount = fromFirst 8 configMonoidConnectionCount configHideTHLoading = fromFirst True configMonoidHideTHLoading clIndices = fromFirst [PackageIndex { indexName = IndexName "Hackage" , indexLocation = "https://s3.amazonaws.com/hackage.fpcomplete.com/" , indexType = ITHackageSecurity HackageSecurity { hsKeyIds = [ "0a5c7ea47cd1b15f01f5f51a33adda7e655bc0f0b0615baa8e271f4c3351e21d" , "1ea9ba32c526d1cc91ab5e5bd364ec5e9e8cb67179a471872f6e26f0ae773d42" , "280b10153a522681163658cb49f632cde3f38d768b736ddbc901d99a1a772833" , "2a96b1889dc221c17296fcc2bb34b908ca9734376f0f361660200935916ef201" , "2c6c3627bd6c982990239487f1abd02e08a02e6cf16edb105a8012d444d870c3" , "51f0161b906011b52c6613376b1ae937670da69322113a246a09f807c62f6921" , "772e9f4c7db33d251d5c6e357199c819e569d130857dc225549b40845ff0890d" , "aa315286e6ad281ad61182235533c41e806e5a787e0b6d1e7eef3f09d137d2e9" , "fe331502606802feac15e514d9b9ea83fee8b6ffef71335479a2e68d84adc6b0" ] , hsKeyThreshold = 3 } , indexDownloadPrefix = "https://s3.amazonaws.com/hackage.fpcomplete.com/package/" , indexRequireHashes = False }] configMonoidPackageIndices configGHCVariant0 = getFirst configMonoidGHCVariant configGHCBuild = getFirst configMonoidGHCBuild configInstallGHC = fromFirst True configMonoidInstallGHC configSkipGHCCheck = fromFirst False configMonoidSkipGHCCheck configSkipMsys = fromFirst False configMonoidSkipMsys configExtraIncludeDirs = configMonoidExtraIncludeDirs configExtraLibDirs = configMonoidExtraLibDirs configOverrideGccPath = getFirst configMonoidOverrideGccPath configOverrideHpack = maybe HpackBundled HpackCommand $ getFirst configMonoidOverrideHpack -- Only place in the codebase where platform is hard-coded. In theory -- in the future, allow it to be configured. (Platform defArch defOS) = buildPlatform arch = fromMaybe defArch $ getFirst configMonoidArch >>= Distribution.Text.simpleParse os = defOS configPlatform = Platform arch os configRequireStackVersion = simplifyVersionRange (getIntersectingVersionRange configMonoidRequireStackVersion) configImage = Image.imgOptsFromMonoid configMonoidImageOpts configCompilerCheck = fromFirst MatchMinor configMonoidCompilerCheck case arch of OtherArch "aarch64" -> return () OtherArch unk -> logWarn $ "Warning: Unknown value for architecture setting: " <> displayShow unk _ -> return () configPlatformVariant <- liftIO $ maybe PlatformVariantNone PlatformVariant <$> lookupEnv platformVariantEnvVar let configBuild = buildOptsFromMonoid configMonoidBuildOpts configDocker <- dockerOptsFromMonoid (fmap fst mproject) clStackRoot mresolver configMonoidDockerOpts configNix <- nixOptsFromMonoid configMonoidNixOpts os configSystemGHC <- case (getFirst configMonoidSystemGHC, nixEnable configNix) of (Just False, True) -> throwM NixRequiresSystemGhc _ -> return (fromFirst (dockerEnable configDocker || nixEnable configNix) configMonoidSystemGHC) when (isJust configGHCVariant0 && configSystemGHC) $ throwM ManualGHCVariantSettingsAreIncompatibleWithSystemGHC rawEnv <- liftIO getEnvironment pathsEnv <- either throwM return $ augmentPathMap (map toFilePath configMonoidExtraPath) (Map.fromList (map (T.pack *** T.pack) rawEnv)) origEnv <- mkProcessContext pathsEnv let configProcessContextSettings _ = return origEnv configLocalProgramsBase <- case getFirst configMonoidLocalProgramsBase of Nothing -> getDefaultLocalProgramsBase clStackRoot configPlatform origEnv Just path -> return path platformOnlyDir <- runReaderT platformOnlyRelDir (configPlatform, configPlatformVariant) let configLocalPrograms = configLocalProgramsBase platformOnlyDir configLocalBin <- case getFirst configMonoidLocalBinPath of Nothing -> do localDir <- getAppUserDataDir "local" return $ localDir $(mkRelDir "bin") Just userPath -> (case mproject of -- Not in a project Nothing -> resolveDir' userPath -- Resolves to the project dir and appends the user path if it is relative Just (_, configYaml) -> resolveDir (parent configYaml) userPath) -- TODO: Either catch specific exceptions or add a -- parseRelAsAbsDirMaybe utility and use it along with -- resolveDirMaybe. `catchAny` const (throwIO (NoSuchDirectory userPath)) configJobs <- case getFirst configMonoidJobs of Nothing -> liftIO getNumProcessors Just i -> return i let configConcurrentTests = fromFirst True configMonoidConcurrentTests let configTemplateParams = configMonoidTemplateParameters configScmInit = getFirst configMonoidScmInit configGhcOptionsByName = coerce configMonoidGhcOptionsByName configGhcOptionsByCat = coerce configMonoidGhcOptionsByCat configSetupInfoLocations = configMonoidSetupInfoLocations configPvpBounds = fromFirst (PvpBounds PvpBoundsNone False) configMonoidPvpBounds configModifyCodePage = fromFirst True configMonoidModifyCodePage configExplicitSetupDeps = configMonoidExplicitSetupDeps configRebuildGhcOptions = fromFirst False configMonoidRebuildGhcOptions configApplyGhcOptions = fromFirst AGOLocals configMonoidApplyGhcOptions configAllowNewer = fromFirst False configMonoidAllowNewer configDefaultTemplate = getFirst configMonoidDefaultTemplate configDumpLogs = fromFirst DumpWarningLogs configMonoidDumpLogs configSaveHackageCreds = fromFirst True configMonoidSaveHackageCreds configHackageBaseUrl = fromFirst "https://hackage.haskell.org/" configMonoidHackageBaseUrl clIgnoreRevisionMismatch = fromFirst False configMonoidIgnoreRevisionMismatch configAllowDifferentUser <- case getFirst configMonoidAllowDifferentUser of Just True -> return True _ -> getInContainer let configMaybeProject = mproject configRunner' <- view runnerL clCache <- newIORef Nothing clUpdateRef <- newMVar True let configRunner = set processContextL origEnv configRunner' configCabalLoader = CabalLoader {..} return Config {..} -- | Get the default location of the local programs directory. getDefaultLocalProgramsBase :: MonadThrow m => Path Abs Dir -> Platform -> ProcessContext -> m (Path Abs Dir) getDefaultLocalProgramsBase configStackRoot configPlatform override = let defaultBase = configStackRoot $(mkRelDir "programs") in case configPlatform of -- For historical reasons, on Windows a subdirectory of LOCALAPPDATA is -- used instead of a subdirectory of STACK_ROOT. Unifying the defaults would -- mean that Windows users would manually have to move data from the old -- location to the new one, which is undesirable. Platform _ Windows -> case Map.lookup "LOCALAPPDATA" $ view envVarsL override of Just t -> case parseAbsDir $ T.unpack t of Nothing -> throwM $ stringException ("Failed to parse LOCALAPPDATA environment variable (expected absolute directory): " ++ show t) Just lad -> return $ lad $(mkRelDir "Programs") $(mkRelDir stackProgName) Nothing -> return defaultBase _ -> return defaultBase -- | An environment with a subset of BuildConfig used for setup. data MiniConfig = MiniConfig -- TODO do we really need a whole extra data type? { mcGHCVariant :: !GHCVariant , mcConfig :: !Config } instance HasConfig MiniConfig where configL = lens mcConfig (\x y -> x { mcConfig = y }) instance HasProcessContext MiniConfig where processContextL = configL.processContextL instance HasCabalLoader MiniConfig where cabalLoaderL = configL.cabalLoaderL instance HasPlatform MiniConfig instance HasGHCVariant MiniConfig where ghcVariantL = lens mcGHCVariant (\x y -> x { mcGHCVariant = y }) instance HasRunner MiniConfig where runnerL = configL.runnerL instance HasLogFunc MiniConfig where logFuncL = configL.logFuncL -- | Load the 'MiniConfig'. loadMiniConfig :: Config -> MiniConfig loadMiniConfig config = MiniConfig { mcGHCVariant = configGHCVariantDefault config , mcConfig = config } configGHCVariantDefault :: Config -> GHCVariant -- FIXME why not just use this as the HasGHCVariant instance for Config? configGHCVariantDefault = fromMaybe GHCStandard . configGHCVariant0 -- Load the configuration, using environment variables, and defaults as -- necessary. loadConfigMaybeProject :: HasRunner env => ConfigMonoid -- ^ Config monoid from parsed command-line arguments -> Maybe AbstractResolver -- ^ Override resolver -> LocalConfigStatus (Project, Path Abs File, ConfigMonoid) -- ^ Project config to use, if any -> RIO env LoadConfig loadConfigMaybeProject configArgs mresolver mproject = do (stackRoot, userOwnsStackRoot) <- determineStackRootAndOwnership configArgs let loadHelper mproject' = do userConfigPath <- getDefaultUserConfigPath stackRoot extraConfigs0 <- getExtraConfigs userConfigPath >>= mapM (\file -> loadConfigYaml (parseConfigMonoid (parent file)) file) let extraConfigs = -- non-project config files' existence of a docker section should never default docker -- to enabled, so make it look like they didn't exist map (\c -> c {configMonoidDockerOpts = (configMonoidDockerOpts c) {dockerMonoidDefaultEnable = Any False}}) extraConfigs0 configFromConfigMonoid stackRoot userConfigPath True -- allow locals mresolver (fmap (\(x, y, _) -> (x, y)) mproject') $ mconcat $ configArgs : maybe id (\(_, _, projectConfig) -> (projectConfig:)) mproject' extraConfigs config <- case mproject of LCSNoConfig _ -> configNoLocalConfig stackRoot mresolver configArgs LCSProject project -> loadHelper $ Just project LCSNoProject -> loadHelper Nothing unless (fromCabalVersion (mkVersion' Meta.version) `withinRange` configRequireStackVersion config) (throwM (BadStackVersionException (configRequireStackVersion config))) let mprojectRoot = fmap (\(_, fp, _) -> parent fp) mproject unless (configAllowDifferentUser config) $ do unless userOwnsStackRoot $ throwM (UserDoesn'tOwnDirectory stackRoot) forM_ mprojectRoot $ \dir -> checkOwnership (dir configWorkDir config) return LoadConfig { lcConfig = config , lcLoadBuildConfig = runRIO config . loadBuildConfig mproject mresolver , lcProjectRoot = case mprojectRoot of LCSProject fp -> Just fp LCSNoProject -> Nothing LCSNoConfig _ -> Nothing } -- | Load the configuration, using current directory, environment variables, -- and defaults as necessary. The passed @Maybe (Path Abs File)@ is an -- override for the location of the project's stack.yaml. loadConfig :: HasRunner env => ConfigMonoid -- ^ Config monoid from parsed command-line arguments -> Maybe AbstractResolver -- ^ Override resolver -> StackYamlLoc (Path Abs File) -- ^ Override stack.yaml -> RIO env LoadConfig loadConfig configArgs mresolver mstackYaml = loadProjectConfig mstackYaml >>= loadConfigMaybeProject configArgs mresolver -- | Load the build configuration, adds build-specific values to config loaded by @loadConfig@. -- values. loadBuildConfig :: LocalConfigStatus (Project, Path Abs File, ConfigMonoid) -> Maybe AbstractResolver -- override resolver -> Maybe (CompilerVersion 'CVWanted) -- override compiler -> RIO Config BuildConfig loadBuildConfig mproject maresolver mcompiler = do config <- ask -- If provided, turn the AbstractResolver from the command line -- into a Resolver that can be used below. -- The maresolver and mcompiler are provided on the command -- line. In order to properly deal with an AbstractResolver, we -- need a base directory (to deal with custom snapshot relative -- paths). We consider the current working directory to be the -- correct base. Let's calculate the mresolver first. mresolver <- forM maresolver $ \aresolver -> do -- For display purposes only let name = case aresolver of ARResolver resolver -> resolverRawName resolver ARLatestNightly -> "nightly" ARLatestLTS -> "lts" ARLatestLTSMajor x -> T.pack $ "lts-" ++ show x ARGlobal -> "global" logDebug ("Using resolver: " <> display name <> " specified on command line") -- In order to resolve custom snapshots, we need a base -- directory to deal with relative paths. For the case of -- LCSNoConfig, we use the parent directory provided. This is -- because, when running the script interpreter, we assume the -- resolver is in fact coming from the file contents itself and -- not the command line. For the project and non project cases, -- however, we use the current directory. base <- case mproject of LCSNoConfig parentDir -> return parentDir LCSProject _ -> resolveDir' "." LCSNoProject -> resolveDir' "." makeConcreteResolver (Just base) aresolver (project', stackYamlFP) <- case mproject of LCSProject (project, fp, _) -> do forM_ (projectUserMsg project) (logWarn . fromString) return (project, fp) LCSNoConfig _ -> do p <- assert (isJust mresolver) (getEmptyProject mresolver) return (p, configUserConfigPath config) LCSNoProject -> do logDebug "Run from outside a project, using implicit global project config" destDir <- getImplicitGlobalProjectDir config let dest :: Path Abs File dest = destDir stackDotYaml dest' :: FilePath dest' = toFilePath dest ensureDir destDir exists <- doesFileExist dest if exists then do ProjectAndConfigMonoid project _ <- loadConfigYaml (parseProjectAndConfigMonoid destDir) dest when (view terminalL config) $ case maresolver of Nothing -> logDebug $ "Using resolver: " <> display (resolverRawName (projectResolver project)) <> " from implicit global project's config file: " <> fromString dest' Just _ -> return () return (project, dest) else do logInfo ("Writing implicit global project config file to: " <> fromString dest') logInfo "Note: You can change the snapshot via the resolver field there." p <- getEmptyProject mresolver liftIO $ do S.writeFile dest' $ S.concat [ "# This is the implicit global project's config file, which is only used when\n" , "# 'stack' is run outside of a real project. Settings here do _not_ act as\n" , "# defaults for all projects. To change stack's default settings, edit\n" , "# '", encodeUtf8 (T.pack $ toFilePath $ configUserConfigPath config), "' instead.\n" , "#\n" , "# For more information about stack's configuration, see\n" , "# http://docs.haskellstack.org/en/stable/yaml_configuration/\n" , "#\n" , Yaml.encode p] S.writeFile (toFilePath $ parent dest $(mkRelFile "README.txt")) $ S.concat [ "This is the implicit global project, which is used only when 'stack' is run\n" , "outside of a real project.\n" ] return (p, dest) let project = project' { projectCompiler = mcompiler <|> projectCompiler project' , projectResolver = fromMaybe (projectResolver project') mresolver } sd0 <- runRIO config $ loadResolver $ projectResolver project let sd = maybe id setCompilerVersion (projectCompiler project) sd0 extraPackageDBs <- mapM resolveDir' (projectExtraPackageDBs project) return BuildConfig { bcConfig = config , bcSnapshotDef = sd , bcGHCVariant = configGHCVariantDefault config , bcPackages = projectPackages project , bcDependencies = projectDependencies project , bcExtraPackageDBs = extraPackageDBs , bcStackYaml = stackYamlFP , bcFlags = projectFlags project , bcImplicitGlobal = case mproject of LCSNoProject -> True LCSProject _ -> False LCSNoConfig _ -> False } where getEmptyProject :: Maybe Resolver -> RIO Config Project getEmptyProject mresolver = do r <- case mresolver of Just resolver -> do logInfo ("Using resolver: " <> display (resolverRawName resolver) <> " specified on command line") return resolver Nothing -> do r'' <- getLatestResolver logInfo ("Using latest snapshot resolver: " <> display (resolverRawName r'')) return r'' return Project { projectUserMsg = Nothing , projectPackages = [] , projectDependencies = [] , projectFlags = mempty , projectResolver = r , projectCompiler = Nothing , projectExtraPackageDBs = [] } -- | Get packages from EnvConfig, downloading and cloning as necessary. -- If the packages have already been downloaded, this uses a cached value. getLocalPackages :: forall env. HasEnvConfig env => RIO env LocalPackages getLocalPackages = do cacheRef <- view $ envConfigL.to envConfigPackagesRef mcached <- liftIO $ readIORef cacheRef case mcached of Just cached -> return cached Nothing -> do root <- view projectRootL bc <- view buildConfigL packages <- do let withName lpv = (lpvName lpv, lpv) map withName . concat <$> mapM (parseMultiCabalFiles root True) (bcPackages bc) let wrapGPD (gpd, loc) = let PackageIdentifier name _version = fromCabalPackageIdentifier $ C.package $ C.packageDescription gpd in (name, (gpd, loc)) deps <- map wrapGPD . concat <$> mapM (parseMultiCabalFilesIndex root) (bcDependencies bc) checkDuplicateNames $ map (second (PLOther . lpvLoc)) packages ++ map (second snd) deps return LocalPackages { lpProject = Map.fromList packages , lpDependencies = Map.fromList deps } -- | Check if there are any duplicate package names and, if so, throw an -- exception. checkDuplicateNames :: MonadThrow m => [(PackageName, PackageLocationIndex FilePath)] -> m () checkDuplicateNames locals = case filter hasMultiples $ Map.toList $ Map.fromListWith (++) $ map (second return) locals of [] -> return () x -> throwM $ DuplicateLocalPackageNames x where hasMultiples (_, _:_:_) = True hasMultiples _ = False -- | Get the stack root, e.g. @~/.stack@, and determine whether the user owns it. -- -- On Windows, the second value is always 'True'. determineStackRootAndOwnership :: (MonadIO m) => ConfigMonoid -- ^ Parsed command-line arguments -> m (Path Abs Dir, Bool) determineStackRootAndOwnership clArgs = liftIO $ do stackRoot <- do case getFirst (configMonoidStackRoot clArgs) of Just x -> return x Nothing -> do mstackRoot <- lookupEnv stackRootEnvVar case mstackRoot of Nothing -> getAppUserDataDir stackProgName Just x -> case parseAbsDir x of Nothing -> throwString ("Failed to parse STACK_ROOT environment variable (expected absolute directory): " ++ show x) Just parsed -> return parsed (existingStackRootOrParentDir, userOwnsIt) <- do mdirAndOwnership <- findInParents getDirAndOwnership stackRoot case mdirAndOwnership of Just x -> return x Nothing -> throwIO (BadStackRoot stackRoot) when (existingStackRootOrParentDir /= stackRoot) $ if userOwnsIt then ensureDir stackRoot else throwIO $ Won'tCreateStackRootInDirectoryOwnedByDifferentUser stackRoot existingStackRootOrParentDir stackRoot' <- canonicalizePath stackRoot return (stackRoot', userOwnsIt) -- | @'checkOwnership' dir@ throws 'UserDoesn'tOwnDirectory' if @dir@ -- isn't owned by the current user. -- -- If @dir@ doesn't exist, its parent directory is checked instead. -- If the parent directory doesn't exist either, @'NoSuchDirectory' ('parent' dir)@ -- is thrown. checkOwnership :: (MonadIO m) => Path Abs Dir -> m () checkOwnership dir = do mdirAndOwnership <- firstJustM getDirAndOwnership [dir, parent dir] case mdirAndOwnership of Just (_, True) -> return () Just (dir', False) -> throwIO (UserDoesn'tOwnDirectory dir') Nothing -> (throwIO . NoSuchDirectory) $ (toFilePathNoTrailingSep . parent) dir -- | @'getDirAndOwnership' dir@ returns @'Just' (dir, 'True')@ when @dir@ -- exists and the current user owns it in the sense of 'isOwnedByUser'. getDirAndOwnership :: (MonadIO m) => Path Abs Dir -> m (Maybe (Path Abs Dir, Bool)) getDirAndOwnership dir = liftIO $ forgivingAbsence $ do ownership <- isOwnedByUser dir return (dir, ownership) -- | Check whether the current user (determined with 'getEffectiveUserId') is -- the owner for the given path. -- -- Will always return 'True' on Windows. isOwnedByUser :: MonadIO m => Path Abs t -> m Bool isOwnedByUser path = liftIO $ do if osIsWindows then return True else do fileStatus <- getFileStatus (toFilePath path) user <- getEffectiveUserID return (user == fileOwner fileStatus) -- | 'True' if we are currently running inside a Docker container. getInContainer :: (MonadIO m) => m Bool getInContainer = liftIO (isJust <$> lookupEnv inContainerEnvVar) -- | 'True' if we are currently running inside a Nix. getInNixShell :: (MonadIO m) => m Bool getInNixShell = liftIO (isJust <$> lookupEnv inNixShellEnvVar) -- | Determine the extra config file locations which exist. -- -- Returns most local first getExtraConfigs :: HasLogFunc env => Path Abs File -- ^ use config path -> RIO env [Path Abs File] getExtraConfigs userConfigPath = do defaultStackGlobalConfigPath <- getDefaultGlobalConfigPath liftIO $ do env <- getEnvironment mstackConfig <- maybe (return Nothing) (fmap Just . parseAbsFile) $ lookup "STACK_CONFIG" env mstackGlobalConfig <- maybe (return Nothing) (fmap Just . parseAbsFile) $ lookup "STACK_GLOBAL_CONFIG" env filterM doesFileExist $ fromMaybe userConfigPath mstackConfig : maybe [] return (mstackGlobalConfig <|> defaultStackGlobalConfigPath) -- | Load and parse YAML from the given config file. Throws -- 'ParseConfigFileException' when there's a decoding error. loadConfigYaml :: HasLogFunc env => (Value -> Yaml.Parser (WithJSONWarnings a)) -> Path Abs File -> RIO env a loadConfigYaml parser path = do eres <- loadYaml parser path case eres of Left err -> liftIO $ throwM (ParseConfigFileException path err) Right res -> return res -- | Load and parse YAML from the given file. loadYaml :: HasLogFunc env => (Value -> Yaml.Parser (WithJSONWarnings a)) -> Path Abs File -> RIO env (Either Yaml.ParseException a) loadYaml parser path = do eres <- liftIO $ Yaml.decodeFileEither (toFilePath path) case eres of Left err -> return (Left err) Right val -> case Yaml.parseEither parser val of Left err -> return (Left (Yaml.AesonException err)) Right (WithJSONWarnings res warnings) -> do logJSONWarnings (toFilePath path) warnings return (Right res) -- | Get the location of the project config file, if it exists. getProjectConfig :: HasLogFunc env => StackYamlLoc (Path Abs File) -- ^ Override stack.yaml -> RIO env (LocalConfigStatus (Path Abs File)) getProjectConfig (SYLOverride stackYaml) = return $ LCSProject stackYaml getProjectConfig SYLDefault = do env <- liftIO getEnvironment case lookup "STACK_YAML" env of Just fp -> do logInfo "Getting project config file from STACK_YAML environment" liftM LCSProject $ resolveFile' fp Nothing -> do currDir <- getCurrentDir maybe LCSNoProject LCSProject <$> findInParents getStackDotYaml currDir where getStackDotYaml dir = do let fp = dir stackDotYaml fp' = toFilePath fp logDebug $ "Checking for project config at: " <> fromString fp' exists <- doesFileExist fp if exists then return $ Just fp else return Nothing getProjectConfig (SYLNoConfig parentDir) = return (LCSNoConfig parentDir) data LocalConfigStatus a = LCSNoProject | LCSProject a | LCSNoConfig !(Path Abs Dir) -- ^ parent directory for making a concrete resolving deriving (Show,Functor,Foldable,Traversable) -- | Find the project config file location, respecting environment variables -- and otherwise traversing parents. If no config is found, we supply a default -- based on current directory. loadProjectConfig :: HasLogFunc env => StackYamlLoc (Path Abs File) -- ^ Override stack.yaml -> RIO env (LocalConfigStatus (Project, Path Abs File, ConfigMonoid)) loadProjectConfig mstackYaml = do mfp <- getProjectConfig mstackYaml case mfp of LCSProject fp -> do currDir <- getCurrentDir logDebug $ "Loading project config file " <> fromString (maybe (toFilePath fp) toFilePath (stripProperPrefix currDir fp)) LCSProject <$> load fp LCSNoProject -> do logDebug "No project config file found, using defaults." return LCSNoProject LCSNoConfig mparentDir -> do logDebug "Ignoring config files" return (LCSNoConfig mparentDir) where load fp = do ProjectAndConfigMonoid project config <- loadConfigYaml (parseProjectAndConfigMonoid (parent fp)) fp return (project, fp, config) -- | Get the location of the default stack configuration file. -- If a file already exists at the deprecated location, its location is returned. -- Otherwise, the new location is returned. getDefaultGlobalConfigPath :: HasLogFunc env => RIO env (Maybe (Path Abs File)) getDefaultGlobalConfigPath = case (defaultGlobalConfigPath, defaultGlobalConfigPathDeprecated) of (Just new,Just old) -> liftM (Just . fst ) $ tryDeprecatedPath (Just "non-project global configuration file") doesFileExist new old (Just new,Nothing) -> return (Just new) _ -> return Nothing -- | Get the location of the default user configuration file. -- If a file already exists at the deprecated location, its location is returned. -- Otherwise, the new location is returned. getDefaultUserConfigPath :: HasLogFunc env => Path Abs Dir -> RIO env (Path Abs File) getDefaultUserConfigPath stackRoot = do (path, exists) <- tryDeprecatedPath (Just "non-project configuration file") doesFileExist (defaultUserConfigPath stackRoot) (defaultUserConfigPathDeprecated stackRoot) unless exists $ do ensureDir (parent path) liftIO $ S.writeFile (toFilePath path) defaultConfigYaml return path -- | Get a fake configuration file location, used when doing a "no -- config" run (the script command). getFakeConfigPath :: (MonadIO m, MonadThrow m) => Path Abs Dir -- ^ stack root -> AbstractResolver -> m (Path Abs File) getFakeConfigPath stackRoot ar = do asString <- case ar of ARResolver r -> return $ T.unpack $ resolverRawName r _ -> throwM $ InvalidResolverForNoLocalConfig $ show ar -- This takeWhile is an ugly hack. We don't actually need this -- path for anything useful. But if we take the raw value for -- a custom snapshot, it will be unparseable in a PATH. -- Therefore, we add in this silly "strip up to :". -- Better would be to defer figuring out this value until -- after we have a fully loaded snapshot with a hash. asDir <- parseRelDir $ takeWhile (/= ':') asString let full = stackRoot $(mkRelDir "script") asDir $(mkRelFile "config.yaml") ensureDir (parent full) return full packagesParser :: Parser [String] packagesParser = many (strOption (long "package" <> help "Additional packages that must be installed")) defaultConfigYaml :: S.ByteString defaultConfigYaml = S.intercalate "\n" [ "# This file contains default non-project-specific settings for 'stack', used" , "# in all projects. For more information about stack's configuration, see" , "# http://docs.haskellstack.org/en/stable/yaml_configuration/" , "" , "# The following parameters are used by \"stack new\" to automatically fill fields" , "# in the cabal config. We recommend uncommenting them and filling them out if" , "# you intend to use 'stack new'." , "# See https://docs.haskellstack.org/en/stable/yaml_configuration/#templates" , "templates:" , " params:" , "# author-name:" , "# author-email:" , "# copyright:" , "# github-username:" , "" ] stack-1.9.3.1/src/Stack/Config/Build.hs0000644000000000000000000001130513455617610015622 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude #-} {-# LANGUAGE RecordWildCards #-} -- | Build configuration module Stack.Config.Build where import Stack.Prelude import Stack.Types.Config -- | Interprets BuildOptsMonoid options. buildOptsFromMonoid :: BuildOptsMonoid -> BuildOpts buildOptsFromMonoid BuildOptsMonoid{..} = BuildOpts { boptsLibProfile = fromFirst (boptsLibProfile defaultBuildOpts) (buildMonoidLibProfile <> First (if tracing || profiling then Just True else Nothing)) , boptsExeProfile = fromFirst (boptsExeProfile defaultBuildOpts) (buildMonoidExeProfile <> First (if tracing || profiling then Just True else Nothing)) , boptsLibStrip = fromFirst (boptsLibStrip defaultBuildOpts) (buildMonoidLibStrip <> First (if noStripping then Just False else Nothing)) , boptsExeStrip = fromFirst (boptsExeStrip defaultBuildOpts) (buildMonoidExeStrip <> First (if noStripping then Just False else Nothing)) , boptsHaddock = fromFirst (boptsHaddock defaultBuildOpts) buildMonoidHaddock , boptsHaddockOpts = haddockOptsFromMonoid buildMonoidHaddockOpts , boptsOpenHaddocks = fromFirst (boptsOpenHaddocks defaultBuildOpts) buildMonoidOpenHaddocks , boptsHaddockDeps = getFirst buildMonoidHaddockDeps , boptsHaddockInternal = fromFirst (boptsHaddockInternal defaultBuildOpts) buildMonoidHaddockInternal , boptsHaddockHyperlinkSource = fromFirst (boptsHaddockHyperlinkSource defaultBuildOpts) buildMonoidHaddockHyperlinkSource , boptsInstallExes = fromFirst (boptsInstallExes defaultBuildOpts) buildMonoidInstallExes , boptsInstallCompilerTool = fromFirst (boptsInstallCompilerTool defaultBuildOpts) buildMonoidInstallCompilerTool , boptsPreFetch = fromFirst (boptsPreFetch defaultBuildOpts) buildMonoidPreFetch , boptsKeepGoing = getFirst buildMonoidKeepGoing , boptsKeepTmpFiles = getFirst buildMonoidKeepTmpFiles , boptsForceDirty = fromFirst (boptsForceDirty defaultBuildOpts) buildMonoidForceDirty , boptsTests = fromFirst (boptsTests defaultBuildOpts) buildMonoidTests , boptsTestOpts = testOptsFromMonoid buildMonoidTestOpts additionalArgs , boptsBenchmarks = fromFirst (boptsBenchmarks defaultBuildOpts) buildMonoidBenchmarks , boptsBenchmarkOpts = benchmarkOptsFromMonoid buildMonoidBenchmarkOpts additionalArgs , boptsReconfigure = fromFirst (boptsReconfigure defaultBuildOpts) buildMonoidReconfigure , boptsCabalVerbose = fromFirst (boptsCabalVerbose defaultBuildOpts) buildMonoidCabalVerbose , boptsSplitObjs = fromFirst (boptsSplitObjs defaultBuildOpts) buildMonoidSplitObjs , boptsSkipComponents = buildMonoidSkipComponents , boptsInterleavedOutput = fromFirst (boptsInterleavedOutput defaultBuildOpts) buildMonoidInterleavedOutput } where -- These options are not directly used in bopts, instead they -- transform other options. tracing = getAny buildMonoidTrace profiling = getAny buildMonoidProfile noStripping = getAny buildMonoidNoStrip -- Additional args for tracing / profiling additionalArgs = if tracing || profiling then Just $ "+RTS" : catMaybes [trac, prof, Just "-RTS"] else Nothing trac = if tracing then Just "-xc" else Nothing prof = if profiling then Just "-p" else Nothing haddockOptsFromMonoid :: HaddockOptsMonoid -> HaddockOpts haddockOptsFromMonoid HaddockOptsMonoid{..} = defaultHaddockOpts {hoAdditionalArgs = hoMonoidAdditionalArgs} testOptsFromMonoid :: TestOptsMonoid -> Maybe [String] -> TestOpts testOptsFromMonoid TestOptsMonoid{..} madditional = defaultTestOpts { toRerunTests = fromFirst (toRerunTests defaultTestOpts) toMonoidRerunTests , toAdditionalArgs = fromMaybe [] madditional <> toMonoidAdditionalArgs , toCoverage = fromFirst (toCoverage defaultTestOpts) toMonoidCoverage , toDisableRun = fromFirst (toDisableRun defaultTestOpts) toMonoidDisableRun } benchmarkOptsFromMonoid :: BenchmarkOptsMonoid -> Maybe [String] -> BenchmarkOpts benchmarkOptsFromMonoid BenchmarkOptsMonoid{..} madditional = defaultBenchmarkOpts { beoAdditionalArgs = fmap (\args -> unwords args <> " ") madditional <> getFirst beoMonoidAdditionalArgs , beoDisableRun = fromFirst (beoDisableRun defaultBenchmarkOpts) beoMonoidDisableRun } stack-1.9.3.1/src/Stack/Config/Urls.hs0000644000000000000000000000145413455617610015514 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude #-} {-# LANGUAGE OverloadedStrings #-} module Stack.Config.Urls (urlsFromMonoid) where import Stack.Types.Urls import Stack.Prelude urlsFromMonoid :: UrlsMonoid -> Urls urlsFromMonoid monoid = Urls (fromFirst defaultLatestSnapshot $ urlsMonoidLatestSnapshot monoid) (fromFirst defaultLtsBuildPlans $ urlsMonoidLtsBuildPlans monoid) (fromFirst defaultNightlyBuildPlans $ urlsMonoidNightlyBuildPlans monoid) where defaultLatestSnapshot = "https://s3.amazonaws.com/haddock.stackage.org/snapshots.json" defaultLtsBuildPlans = "https://raw.githubusercontent.com/fpco/lts-haskell/master/" defaultNightlyBuildPlans = "https://raw.githubusercontent.com/fpco/stackage-nightly/master/" stack-1.9.3.1/src/Stack/Config/Docker.hs0000644000000000000000000001073213455617610015775 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude #-} {-# LANGUAGE CPP, DeriveDataTypeable, RecordWildCards, TemplateHaskell #-} -- | Docker configuration module Stack.Config.Docker where import Stack.Prelude import Data.List (find) import qualified Data.Text as T import Distribution.Version (simplifyVersionRange) import Path import Stack.Types.Version import Stack.Types.Config import Stack.Types.Docker import Stack.Types.Resolver -- | Interprets DockerOptsMonoid options. dockerOptsFromMonoid :: MonadThrow m => Maybe Project -> Path Abs Dir -> Maybe AbstractResolver -> DockerOptsMonoid -> m DockerOpts dockerOptsFromMonoid mproject stackRoot maresolver DockerOptsMonoid{..} = do let dockerEnable = fromFirst (getAny dockerMonoidDefaultEnable) dockerMonoidEnable dockerImage = let mresolver = case maresolver of Just (ARResolver resolver) -> Just (void resolver) Just aresolver -> impureThrow (ResolverNotSupportedException $ show aresolver) Nothing -> fmap (void . projectResolver) mproject defaultTag = case mresolver of Nothing -> "" Just resolver -> case resolver of ResolverStackage n@(LTS _ _) -> ":" ++ T.unpack (renderSnapName n) _ -> impureThrow (ResolverNotSupportedException $ show resolver) in case getFirst dockerMonoidRepoOrImage of Nothing -> "fpco/stack-build" ++ defaultTag Just (DockerMonoidImage image) -> image Just (DockerMonoidRepo repo) -> case find (`elem` (":@" :: String)) repo of Just _ -- Repo already specified a tag or digest, so don't append default -> repo Nothing -> repo ++ defaultTag dockerRegistryLogin = fromFirst (isJust (emptyToNothing (getFirst dockerMonoidRegistryUsername))) dockerMonoidRegistryLogin dockerRegistryUsername = emptyToNothing (getFirst dockerMonoidRegistryUsername) dockerRegistryPassword = emptyToNothing (getFirst dockerMonoidRegistryPassword) dockerAutoPull = fromFirst False dockerMonoidAutoPull dockerDetach = fromFirst False dockerMonoidDetach dockerPersist = fromFirst False dockerMonoidPersist dockerContainerName = emptyToNothing (getFirst dockerMonoidContainerName) dockerRunArgs = dockerMonoidRunArgs dockerMount = dockerMonoidMount dockerEnv = dockerMonoidEnv dockerSetUser = getFirst dockerMonoidSetUser dockerRequireDockerVersion = simplifyVersionRange (getIntersectingVersionRange dockerMonoidRequireDockerVersion) dockerDatabasePath = fromFirst (stackRoot $(mkRelFile "docker.db")) dockerMonoidDatabasePath dockerStackExe = getFirst dockerMonoidStackExe return DockerOpts{..} where emptyToNothing Nothing = Nothing emptyToNothing (Just s) | null s = Nothing | otherwise = Just s -- | Exceptions thrown by Stack.Docker.Config. data StackDockerConfigException = ResolverNotSupportedException String -- ^ Only LTS resolvers are supported for default image tag. | InvalidDatabasePathException SomeException -- ^ Invalid global database path. deriving (Typeable) -- | Exception instance for StackDockerConfigException. instance Exception StackDockerConfigException -- | Show instance for StackDockerConfigException. instance Show StackDockerConfigException where show (ResolverNotSupportedException resolver) = concat [ "Resolver not supported for Docker images:\n " , resolver , "\nUse an LTS resolver, or set the '" , T.unpack dockerImageArgName , "' explicitly, in your configuration file."] show (InvalidDatabasePathException ex) = "Invalid database path: " ++ show ex stack-1.9.3.1/src/Stack/Config/Nix.hs0000644000000000000000000000714713455617610015332 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude #-} {-# LANGUAGE RecordWildCards, DeriveDataTypeable, OverloadedStrings #-} -- | Nix configuration module Stack.Config.Nix (nixOptsFromMonoid ,nixCompiler ,StackNixException(..) ) where import Stack.Prelude import Control.Monad.Extra (ifM) import qualified Data.Text as T import qualified Data.Text.IO as TIO import Distribution.System (OS (..)) import Stack.Constants import Stack.Types.Version import Stack.Types.Nix import Stack.Types.Compiler import Stack.Types.Runner import System.Directory (doesFileExist) -- | Interprets NixOptsMonoid options. nixOptsFromMonoid :: HasRunner env => NixOptsMonoid -> OS -> RIO env NixOpts nixOptsFromMonoid NixOptsMonoid{..} os = do let defaultPure = case os of OSX -> False _ -> True nixPureShell = fromFirst defaultPure nixMonoidPureShell nixPackages = fromFirst [] nixMonoidPackages nixInitFile = getFirst nixMonoidInitFile nixShellOptions = fromFirst [] nixMonoidShellOptions ++ prefixAll (T.pack "-I") (fromFirst [] nixMonoidPath) nixAddGCRoots = fromFirst False nixMonoidAddGCRoots -- Enable Nix-mode by default on NixOS, unless Docker-mode was specified osIsNixOS <- isNixOS let nixEnable0 = fromFirst osIsNixOS nixMonoidEnable nixEnable <- case () of _ | nixEnable0 && osIsWindows -> do logInfo "Note: Disabling nix integration, since this is being run in Windows" return False | otherwise -> return nixEnable0 when (not (null nixPackages) && isJust nixInitFile) $ throwIO NixCannotUseShellFileAndPackagesException return NixOpts{..} where prefixAll p (x:xs) = p : x : prefixAll p xs prefixAll _ _ = [] nixCompiler :: CompilerVersion a -> Either StringException T.Text nixCompiler compilerVersion = case compilerVersion of GhcVersion version -> case T.split (== '.') (versionText version) of x : y : minor -> Right $ case minor of [] -> -- The minor version is not specified. Select the latest minor -- version in Nixpkgs corresponding to the requested major -- version. let major = T.concat [x, y] in "(let compilers = builtins.filter \ \(name: builtins.match \ \\"ghc" <> major <> "[[:digit:]]*\" name != null) \ \(lib.attrNames haskell.compiler); in \ \if compilers == [] \ \then abort \"No compiler found for GHC " <> versionText version <> "\"\ \else haskell.compiler.${builtins.head compilers})" _ -> "haskell.compiler.ghc" <> T.concat (x : y : minor) _ -> Left $ stringException "GHC major version not specified" _ -> Left $ stringException "Only GHC is supported by stack --nix" -- Exceptions thown specifically by Stack.Nix data StackNixException = NixCannotUseShellFileAndPackagesException -- ^ Nix can't be given packages and a shell file at the same time deriving (Typeable) instance Exception StackNixException instance Show StackNixException where show NixCannotUseShellFileAndPackagesException = "You cannot have packages and a shell-file filled at the same time in your nix-shell configuration." isNixOS :: MonadIO m => m Bool isNixOS = liftIO $ do let fp = "/etc/os-release" ifM (doesFileExist fp) (T.isInfixOf "ID=nixos" <$> TIO.readFile fp) (return False) stack-1.9.3.1/src/Stack/ConfigCmd.hs0000644000000000000000000001352013455617610015210 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude #-} {-# LANGUAGE ConstraintKinds #-} {-# LANGUAGE FlexibleContexts #-} {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE GADTs #-} -- | Make changes to project or global configuration. module Stack.ConfigCmd (ConfigCmdSet(..) ,configCmdSetParser ,cfgCmdSet ,cfgCmdSetName ,cfgCmdName) where import Stack.Prelude import qualified Data.ByteString as S import qualified Data.HashMap.Strict as HMap import qualified Data.Text as T import qualified Data.Yaml as Yaml import qualified Options.Applicative as OA import qualified Options.Applicative.Types as OA import Path import Path.IO import Stack.Config (makeConcreteResolver, getProjectConfig, getImplicitGlobalProjectDir, LocalConfigStatus(..)) import Stack.Constants import Stack.Snapshot (loadResolver) import Stack.Types.Config import Stack.Types.Resolver data ConfigCmdSet = ConfigCmdSetResolver AbstractResolver | ConfigCmdSetSystemGhc CommandScope Bool | ConfigCmdSetInstallGhc CommandScope Bool data CommandScope = CommandScopeGlobal -- ^ Apply changes to the global configuration, -- typically at @~/.stack/config.yaml@. | CommandScopeProject -- ^ Apply changes to the project @stack.yaml@. configCmdSetScope :: ConfigCmdSet -> CommandScope configCmdSetScope (ConfigCmdSetResolver _) = CommandScopeProject configCmdSetScope (ConfigCmdSetSystemGhc scope _) = scope configCmdSetScope (ConfigCmdSetInstallGhc scope _) = scope cfgCmdSet :: (HasConfig env, HasGHCVariant env) => GlobalOpts -> ConfigCmdSet -> RIO env () cfgCmdSet go cmd = do conf <- view configL configFilePath <- case configCmdSetScope cmd of CommandScopeProject -> do mstackYamlOption <- forM (globalStackYaml go) resolveFile' mstackYaml <- getProjectConfig mstackYamlOption case mstackYaml of LCSProject stackYaml -> return stackYaml LCSNoProject -> liftM ( stackDotYaml) (getImplicitGlobalProjectDir conf) LCSNoConfig _ -> throwString "config command used when no local configuration available" CommandScopeGlobal -> return (configUserConfigPath conf) -- We don't need to worry about checking for a valid yaml here (config :: Yaml.Object) <- liftIO (Yaml.decodeFileEither (toFilePath configFilePath)) >>= either throwM return newValue <- cfgCmdSetValue (parent configFilePath) cmd let cmdKey = cfgCmdSetOptionName cmd config' = HMap.insert cmdKey newValue config if config' == config then logInfo (fromString (toFilePath configFilePath) <> " already contained the intended configuration and remains unchanged.") else do liftIO (S.writeFile (toFilePath configFilePath) (Yaml.encode config')) logInfo (fromString (toFilePath configFilePath) <> " has been updated.") cfgCmdSetValue :: (HasConfig env, HasGHCVariant env) => Path Abs Dir -- ^ root directory of project -> ConfigCmdSet -> RIO env Yaml.Value cfgCmdSetValue root (ConfigCmdSetResolver newResolver) = do concreteResolver <- makeConcreteResolver (Just root) newResolver -- Check that the snapshot actually exists void $ loadResolver concreteResolver return (Yaml.toJSON concreteResolver) cfgCmdSetValue _ (ConfigCmdSetSystemGhc _ bool') = return (Yaml.Bool bool') cfgCmdSetValue _ (ConfigCmdSetInstallGhc _ bool') = return (Yaml.Bool bool') cfgCmdSetOptionName :: ConfigCmdSet -> Text cfgCmdSetOptionName (ConfigCmdSetResolver _) = "resolver" cfgCmdSetOptionName (ConfigCmdSetSystemGhc _ _) = configMonoidSystemGHCName cfgCmdSetOptionName (ConfigCmdSetInstallGhc _ _) = configMonoidInstallGHCName cfgCmdName :: String cfgCmdName = "config" cfgCmdSetName :: String cfgCmdSetName = "set" configCmdSetParser :: OA.Parser ConfigCmdSet configCmdSetParser = OA.hsubparser $ mconcat [ OA.command "resolver" (OA.info (ConfigCmdSetResolver <$> OA.argument readAbstractResolver (OA.metavar "RESOLVER" <> OA.help "E.g. \"nightly\" or \"lts-7.2\"")) (OA.progDesc "Change the resolver of the current project. See https://docs.haskellstack.org/en/stable/yaml_configuration/#resolver for more info.")) , OA.command (T.unpack configMonoidSystemGHCName) (OA.info (ConfigCmdSetSystemGhc <$> scopeFlag <*> boolArgument) (OA.progDesc "Configure whether stack should use a system GHC installation or not.")) , OA.command (T.unpack configMonoidInstallGHCName) (OA.info (ConfigCmdSetInstallGhc <$> scopeFlag <*> boolArgument) (OA.progDesc "Configure whether stack should automatically install GHC when necessary.")) ] scopeFlag :: OA.Parser CommandScope scopeFlag = OA.flag CommandScopeProject CommandScopeGlobal (OA.long "global" <> OA.help "Modify the global configuration (typically at \"~/.stack/config.yaml\") instead of the project stack.yaml.") readBool :: OA.ReadM Bool readBool = do s <- OA.readerAsk case s of "true" -> return True "false" -> return False _ -> OA.readerError ("Invalid value " ++ show s ++ ": Expected \"true\" or \"false\"") boolArgument :: OA.Parser Bool boolArgument = OA.argument readBool (OA.metavar "true|false" <> OA.completeWith ["true", "false"]) stack-1.9.3.1/src/Stack/Constants.hs0000644000000000000000000001720313455617610015335 0ustar0000000000000000{-# LANGUAGE CPP #-} {-# LANGUAGE NoImplicitPrelude #-} {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TemplateHaskell #-} -- | Constants used throughout the project. module Stack.Constants (buildPlanDir ,buildPlanCacheDir ,haskellModuleExts ,stackDotYaml ,stackWorkEnvVar ,stackRootEnvVar ,stackRootOptionName ,deprecatedStackRootOptionName ,inContainerEnvVar ,inNixShellEnvVar ,stackProgName ,stackProgNameUpper ,wiredInPackages ,ghcjsBootPackages ,cabalPackageName ,implicitGlobalProjectDirDeprecated ,implicitGlobalProjectDir ,defaultUserConfigPathDeprecated ,defaultUserConfigPath ,defaultGlobalConfigPathDeprecated ,defaultGlobalConfigPath ,platformVariantEnvVar ,compilerOptionsCabalFlag ,ghcColorForceFlag ,minTerminalWidth ,maxTerminalWidth ,defaultTerminalWidth ,osIsWindows ) where import Data.Char (toUpper) import qualified Data.HashSet as HashSet import Path as FL import Stack.Prelude import Stack.Types.Compiler import Stack.Types.PackageName -- | Extensions for anything that can be a Haskell module. haskellModuleExts :: [Text] haskellModuleExts = haskellFileExts ++ haskellPreprocessorExts -- | Extensions used for Haskell modules. Excludes preprocessor ones. haskellFileExts :: [Text] haskellFileExts = ["hs", "hsc", "lhs"] -- | Extensions for modules that are preprocessed by common preprocessors. haskellPreprocessorExts :: [Text] haskellPreprocessorExts = ["gc", "chs", "hsc", "x", "y", "ly", "cpphs"] -- | Name of the 'stack' program, uppercased stackProgNameUpper :: String stackProgNameUpper = map toUpper stackProgName -- | Name of the 'stack' program. stackProgName :: String stackProgName = "stack" -- | The filename used for the stack config file. stackDotYaml :: Path Rel File stackDotYaml = $(mkRelFile "stack.yaml") -- | Environment variable used to override the '.stack-work' relative dir. stackWorkEnvVar :: String stackWorkEnvVar = "STACK_WORK" -- | Environment variable used to override the '~/.stack' location. stackRootEnvVar :: String stackRootEnvVar = "STACK_ROOT" -- | Option name for the global stack root. stackRootOptionName :: String stackRootOptionName = "stack-root" -- | Deprecated option name for the global stack root. -- -- Deprecated since stack-1.1.0. -- -- TODO: Remove occurences of this variable and use 'stackRootOptionName' only -- after an appropriate deprecation period. deprecatedStackRootOptionName :: String deprecatedStackRootOptionName = "global-stack-root" -- | Environment variable used to indicate stack is running in container. inContainerEnvVar :: String inContainerEnvVar = stackProgNameUpper ++ "_IN_CONTAINER" -- | Environment variable used to indicate stack is running in container. -- although we already have STACK_IN_NIX_EXTRA_ARGS that is set in the same conditions, -- it can happen that STACK_IN_NIX_EXTRA_ARGS is set to empty. inNixShellEnvVar :: String inNixShellEnvVar = map toUpper stackProgName ++ "_IN_NIX_SHELL" -- See https://downloads.haskell.org/~ghc/7.10.1/docs/html/libraries/ghc/src/Module.html#integerPackageKey wiredInPackages :: HashSet PackageName wiredInPackages = maybe (error "Parse error in wiredInPackages") HashSet.fromList mparsed where mparsed = mapM parsePackageName [ "ghc-prim" , "integer-gmp" , "integer-simple" , "base" , "rts" , "template-haskell" , "dph-seq" , "dph-par" , "ghc" , "interactive" ] -- TODO: Get this unwieldy list out of here and into a datafile -- generated by GHCJS! See https://github.com/ghcjs/ghcjs/issues/434 ghcjsBootPackages :: HashSet PackageName ghcjsBootPackages = maybe (error "Parse error in ghcjsBootPackages") HashSet.fromList mparsed where mparsed = mapM parsePackageName -- stage1a [ "array" , "base" , "binary" , "bytestring" , "containers" , "deepseq" , "integer-gmp" , "pretty" , "primitive" , "integer-gmp" , "pretty" , "primitive" , "template-haskell" , "transformers" -- stage1b , "directory" , "filepath" , "old-locale" , "process" , "time" -- stage2 , "async" , "aeson" , "attoparsec" , "case-insensitive" , "dlist" , "extensible-exceptions" , "hashable" , "mtl" , "old-time" , "parallel" , "scientific" , "stm" , "syb" , "text" , "unordered-containers" , "vector" ] -- | Just to avoid repetition and magic strings. cabalPackageName :: PackageName cabalPackageName = $(mkPackageName "Cabal") -- | Deprecated implicit global project directory used when outside of a project. implicitGlobalProjectDirDeprecated :: Path Abs Dir -- ^ Stack root. -> Path Abs Dir implicitGlobalProjectDirDeprecated p = p $(mkRelDir "global") -- | Implicit global project directory used when outside of a project. -- Normally, @getImplicitGlobalProjectDir@ should be used instead. implicitGlobalProjectDir :: Path Abs Dir -- ^ Stack root. -> Path Abs Dir implicitGlobalProjectDir p = p $(mkRelDir "global-project") -- | Deprecated default global config path. defaultUserConfigPathDeprecated :: Path Abs Dir -> Path Abs File defaultUserConfigPathDeprecated = ( $(mkRelFile "stack.yaml")) -- | Default global config path. -- Normally, @getDefaultUserConfigPath@ should be used instead. defaultUserConfigPath :: Path Abs Dir -> Path Abs File defaultUserConfigPath = ( $(mkRelFile "config.yaml")) -- | Deprecated default global config path. -- Note that this will be @Nothing@ on Windows, which is by design. defaultGlobalConfigPathDeprecated :: Maybe (Path Abs File) defaultGlobalConfigPathDeprecated = parseAbsFile "/etc/stack/config" -- | Default global config path. -- Normally, @getDefaultGlobalConfigPath@ should be used instead. -- Note that this will be @Nothing@ on Windows, which is by design. defaultGlobalConfigPath :: Maybe (Path Abs File) defaultGlobalConfigPath = parseAbsFile "/etc/stack/config.yaml" -- | Path where build plans are stored. buildPlanDir :: Path Abs Dir -- ^ Stack root -> Path Abs Dir buildPlanDir = ( $(mkRelDir "build-plan")) -- | Path where binary caches of the build plans are stored. buildPlanCacheDir :: Path Abs Dir -- ^ Stack root -> Path Abs Dir buildPlanCacheDir = ( $(mkRelDir "build-plan-cache")) -- | Environment variable that stores a variant to append to platform-specific directory -- names. Used to ensure incompatible binaries aren't shared between Docker builds and host platformVariantEnvVar :: String platformVariantEnvVar = stackProgNameUpper ++ "_PLATFORM_VARIANT" -- | Provides --ghc-options for 'Ghc', and similarly, --ghcjs-options -- for 'Ghcjs'. compilerOptionsCabalFlag :: WhichCompiler -> String compilerOptionsCabalFlag Ghc = "--ghc-options" compilerOptionsCabalFlag Ghcjs = "--ghcjs-options" -- | The flag to pass to GHC when we want to force its output to be -- colorized. ghcColorForceFlag :: String ghcColorForceFlag = "-fdiagnostics-color=always" -- | The minimum allowed terminal width. Used for pretty-printing. minTerminalWidth :: Int minTerminalWidth = 40 -- | The maximum allowed terminal width. Used for pretty-printing. maxTerminalWidth :: Int maxTerminalWidth = 200 -- | The default terminal width. Used for pretty-printing when we can't -- automatically detect it and when the user doesn't supply one. defaultTerminalWidth :: Int defaultTerminalWidth = 100 -- | True if using Windows OS. osIsWindows :: Bool osIsWindows = #ifdef WINDOWS True #else False #endif stack-1.9.3.1/src/Stack/Constants/Config.hs0000644000000000000000000001230213455617610016535 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude #-} {-# LANGUAGE TemplateHaskell #-} {-# LANGUAGE OverloadedStrings #-} module Stack.Constants.Config ( distDirFromDir , workDirFromDir , distRelativeDir , imageStagingDir , projectDockerSandboxDir , configCacheFile , configCabalMod , buildCachesDir , testSuccessFile , testBuiltFile , hpcRelativeDir , hpcDirFromDir , objectInterfaceDirL , ghciDirL , templatesDir ) where import Stack.Prelude import Stack.Constants import Stack.Types.Compiler import Stack.Types.Config import Stack.Types.PackageIdentifier import Path -- | Output .o/.hi directory. objectInterfaceDirL :: HasBuildConfig env => Getting r env (Path Abs Dir) objectInterfaceDirL = to $ \env -> -- FIXME is this idomatic lens code? let workDir = view workDirL env root = view projectRootL env in root workDir $(mkRelDir "odir/") -- | GHCi files directory. ghciDirL :: HasBuildConfig env => Getting r env (Path Abs Dir) ghciDirL = to $ \env -> -- FIXME is this idomatic lens code? let workDir = view workDirL env root = view projectRootL env in root workDir $(mkRelDir "ghci/") -- | The directory containing the files used for dirtiness check of source files. buildCachesDir :: (MonadThrow m, MonadReader env m, HasEnvConfig env) => Path Abs Dir -- ^ Package directory. -> m (Path Abs Dir) buildCachesDir dir = liftM ( $(mkRelDir "stack-build-caches")) (distDirFromDir dir) -- | The filename used to mark tests as having succeeded testSuccessFile :: (MonadThrow m, MonadReader env m, HasEnvConfig env) => Path Abs Dir -- ^ Package directory -> m (Path Abs File) testSuccessFile dir = liftM ( $(mkRelFile "stack-test-success")) (distDirFromDir dir) -- | The filename used to mark tests as having built testBuiltFile :: (MonadThrow m, MonadReader env m, HasEnvConfig env) => Path Abs Dir -- ^ Package directory -> m (Path Abs File) testBuiltFile dir = liftM ( $(mkRelFile "stack-test-built")) (distDirFromDir dir) -- | The filename used for dirtiness check of config. configCacheFile :: (MonadThrow m, MonadReader env m, HasEnvConfig env) => Path Abs Dir -- ^ Package directory. -> m (Path Abs File) configCacheFile dir = liftM ( $(mkRelFile "stack-config-cache")) (distDirFromDir dir) -- | The filename used for modification check of .cabal configCabalMod :: (MonadThrow m, MonadReader env m, HasEnvConfig env) => Path Abs Dir -- ^ Package directory. -> m (Path Abs File) configCabalMod dir = liftM ( $(mkRelFile "stack-cabal-mod")) (distDirFromDir dir) -- | Directory for HPC work. hpcDirFromDir :: (MonadThrow m, MonadReader env m, HasEnvConfig env) => Path Abs Dir -- ^ Package directory. -> m (Path Abs Dir) hpcDirFromDir fp = liftM (fp ) hpcRelativeDir -- | Relative location of directory for HPC work. hpcRelativeDir :: (MonadThrow m, MonadReader env m, HasEnvConfig env) => m (Path Rel Dir) hpcRelativeDir = liftM ( $(mkRelDir "hpc")) distRelativeDir -- | Package's build artifacts directory. distDirFromDir :: (MonadThrow m, MonadReader env m, HasEnvConfig env) => Path Abs Dir -> m (Path Abs Dir) distDirFromDir fp = liftM (fp ) distRelativeDir -- | Package's working directory. workDirFromDir :: (MonadReader env m, HasEnvConfig env) => Path Abs Dir -> m (Path Abs Dir) workDirFromDir fp = view $ workDirL.to (fp ) -- | Directory for project templates. templatesDir :: Config -> Path Abs Dir templatesDir config = view stackRootL config $(mkRelDir "templates") -- | Relative location of build artifacts. distRelativeDir :: (MonadThrow m, MonadReader env m, HasEnvConfig env) => m (Path Rel Dir) distRelativeDir = do cabalPkgVer <- view cabalVersionL platform <- platformGhcRelDir wc <- view $ actualCompilerVersionL.to whichCompiler -- Cabal version, suffixed with "_ghcjs" if we're using GHCJS. envDir <- parseRelDir $ (if wc == Ghcjs then (++ "_ghcjs") else id) $ packageIdentifierString $ PackageIdentifier cabalPackageName cabalPkgVer platformAndCabal <- useShaPathOnWindows (platform envDir) workDir <- view workDirL return $ workDir $(mkRelDir "dist") platformAndCabal -- | Docker sandbox from project root. projectDockerSandboxDir :: (MonadReader env m, HasConfig env) => Path Abs Dir -- ^ Project root -> m (Path Abs Dir) -- ^ Docker sandbox projectDockerSandboxDir projectRoot = do workDir <- view workDirL return $ projectRoot workDir $(mkRelDir "docker/") -- | Image staging dir from project root. imageStagingDir :: (MonadReader env m, HasConfig env, MonadThrow m) => Path Abs Dir -- ^ Project root -> Int -- ^ Index of image -> m (Path Abs Dir) -- ^ Docker sandbox imageStagingDir projectRoot imageIdx = do workDir <- view workDirL idxRelDir <- parseRelDir (show imageIdx) return $ projectRoot workDir $(mkRelDir "image") idxRelDir stack-1.9.3.1/src/Stack/Coverage.hs0000644000000000000000000005755113455671116015127 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude #-} {-# LANGUAGE ConstraintKinds #-} {-# LANGUAGE FlexibleContexts #-} {-# LANGUAGE MultiParamTypeClasses #-} {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE TemplateHaskell #-} {-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE LambdaCase #-} {-# LANGUAGE TupleSections #-} -- | Generate HPC (Haskell Program Coverage) reports module Stack.Coverage ( deleteHpcReports , updateTixFile , generateHpcReport , HpcReportOpts(..) , generateHpcReportForTargets , generateHpcUnifiedReport , generateHpcMarkupIndex ) where import Stack.Prelude hiding (Display (..)) import qualified Data.ByteString.Char8 as S8 import qualified Data.ByteString.Lazy as BL import Data.List import qualified Data.Map.Strict as Map import qualified Data.Set as Set import qualified Data.Text as T import qualified Data.Text.IO as T import qualified Data.Text.Lazy as LT import Path import Path.Extra (toFilePathNoTrailingSep) import Path.IO import Stack.Build.Target import Stack.Config (getLocalPackages) import Stack.Constants.Config import Stack.Package import Stack.PrettyPrint import Stack.Types.Compiler import Stack.Types.Config import Stack.Types.NamedComponent import Stack.Types.Package import Stack.Types.PackageIdentifier import Stack.Types.PackageName import Stack.Types.Runner import Stack.Types.Version import System.FilePath (isPathSeparator) import qualified RIO import RIO.Process import Trace.Hpc.Tix import Web.Browser (openBrowser) -- | Invoked at the beginning of running with "--coverage" deleteHpcReports :: HasEnvConfig env => RIO env () deleteHpcReports = do hpcDir <- hpcReportDir liftIO $ ignoringAbsence (removeDirRecur hpcDir) -- | Move a tix file into a sub-directory of the hpc report directory. Deletes the old one if one is -- present. updateTixFile :: HasEnvConfig env => PackageName -> Path Abs File -> String -> RIO env () updateTixFile pkgName tixSrc testName = do exists <- doesFileExist tixSrc when exists $ do tixDest <- tixFilePath pkgName testName liftIO $ ignoringAbsence (removeFile tixDest) ensureDir (parent tixDest) -- Remove exe modules because they are problematic. This could be revisited if there's a GHC -- version that fixes https://ghc.haskell.org/trac/ghc/ticket/1853 mtix <- readTixOrLog tixSrc case mtix of Nothing -> logError $ "Failed to read " <> fromString (toFilePath tixSrc) Just tix -> do liftIO $ writeTix (toFilePath tixDest) (removeExeModules tix) -- TODO: ideally we'd do a file move, but IIRC this can -- have problems. Something about moving between drives -- on windows? copyFile tixSrc =<< parseAbsFile (toFilePath tixDest ++ ".premunging") liftIO $ ignoringAbsence (removeFile tixSrc) -- | Get the directory used for hpc reports for the given pkgId. hpcPkgPath :: HasEnvConfig env => PackageName -> RIO env (Path Abs Dir) hpcPkgPath pkgName = do outputDir <- hpcReportDir pkgNameRel <- parseRelDir (packageNameString pkgName) return (outputDir pkgNameRel) -- | Get the tix file location, given the name of the file (without extension), and the package -- identifier string. tixFilePath :: HasEnvConfig env => PackageName -> String -> RIO env (Path Abs File) tixFilePath pkgName testName = do pkgPath <- hpcPkgPath pkgName tixRel <- parseRelFile (testName ++ "/" ++ testName ++ ".tix") return (pkgPath tixRel) -- | Generates the HTML coverage report and shows a textual coverage summary for a package. generateHpcReport :: HasEnvConfig env => Path Abs Dir -> Package -> [Text] -> RIO env () generateHpcReport pkgDir package tests = do compilerVersion <- view actualCompilerVersionL -- If we're using > GHC 7.10, the hpc 'include' parameter must specify a ghc package key. See -- https://github.com/commercialhaskell/stack/issues/785 let pkgName = packageNameText (packageName package) pkgId = packageIdentifierString (packageIdentifier package) ghcVersion = getGhcVersion compilerVersion hasLibrary = case packageLibraries package of NoLibraries -> False HasLibraries _ -> True internalLibs = packageInternalLibraries package eincludeName <- -- Pre-7.8 uses plain PKG-version in tix files. if ghcVersion < $(mkVersion "7.10") then return $ Right $ Just [pkgId] -- We don't expect to find a package key if there is no library. else if not hasLibrary && Set.null internalLibs then return $ Right Nothing -- Look in the inplace DB for the package key. -- See https://github.com/commercialhaskell/stack/issues/1181#issuecomment-148968986 else do -- GHC 8.0 uses package id instead of package key. -- See https://github.com/commercialhaskell/stack/issues/2424 let hpcNameField = if ghcVersion >= $(mkVersion "8.0") then "id" else "key" eincludeName <- findPackageFieldForBuiltPackage pkgDir (packageIdentifier package) internalLibs hpcNameField case eincludeName of Left err -> do logError $ RIO.display err return $ Left err Right includeNames -> return $ Right $ Just $ map T.unpack includeNames forM_ tests $ \testName -> do tixSrc <- tixFilePath (packageName package) (T.unpack testName) let report = "coverage report for " <> pkgName <> "'s test-suite \"" <> testName <> "\"" reportDir = parent tixSrc case eincludeName of Left err -> generateHpcErrorReport reportDir (RIO.display (sanitize (T.unpack err))) -- Restrict to just the current library code, if there is a library in the package (see -- #634 - this will likely be customizable in the future) Right mincludeName -> do let extraArgs = case mincludeName of Just includeNames -> "--include" : intersperse "--include" (map (\n -> n ++ ":") includeNames) Nothing -> [] mreportPath <- generateHpcReportInternal tixSrc reportDir report extraArgs extraArgs forM_ mreportPath (displayReportPath report . display) generateHpcReportInternal :: HasEnvConfig env => Path Abs File -> Path Abs Dir -> Text -> [String] -> [String] -> RIO env (Maybe (Path Abs File)) generateHpcReportInternal tixSrc reportDir report extraMarkupArgs extraReportArgs = do -- If a .tix file exists, move it to the HPC output directory and generate a report for it. tixFileExists <- doesFileExist tixSrc if not tixFileExists then do logError $ "Didn't find .tix for " <> RIO.display report <> " - expected to find it at " <> fromString (toFilePath tixSrc) <> "." return Nothing else (`catch` \(err :: ProcessException) -> do logError $ displayShow err generateHpcErrorReport reportDir $ RIO.display $ sanitize $ show err return Nothing) $ (`onException` logError ("Error occurred while producing " <> RIO.display report)) $ do -- Directories for .mix files. hpcRelDir <- hpcRelativeDir -- Compute arguments used for both "hpc markup" and "hpc report". pkgDirs <- liftM (map lpvRoot . Map.elems . lpProject) getLocalPackages let args = -- Use index files from all packages (allows cross-package coverage results). concatMap (\x -> ["--srcdir", toFilePathNoTrailingSep x]) pkgDirs ++ -- Look for index files in the correct dir (relative to each pkgdir). ["--hpcdir", toFilePathNoTrailingSep hpcRelDir, "--reset-hpcdirs"] logInfo $ "Generating " <> RIO.display report outputLines <- liftM (map (S8.filter (/= '\r')) . S8.lines . BL.toStrict . fst) $ proc "hpc" ( "report" : toFilePath tixSrc : (args ++ extraReportArgs) ) readProcess_ if all ("(0/0)" `S8.isSuffixOf`) outputLines then do let msg html = "Error: The " <> RIO.display report <> " did not consider any code. One possible cause of this is" <> " if your test-suite builds the library code (see stack " <> (if html then "" else "") <> "issue #1008" <> (if html then "" else "") <> "). It may also indicate a bug in stack or" <> " the hpc program. Please report this issue if you think" <> " your coverage report should have meaningful results." logError (msg False) generateHpcErrorReport reportDir (msg True) return Nothing else do let reportPath = reportDir $(mkRelFile "hpc_index.html") -- Print output, stripping @\r@ characters because Windows. forM_ outputLines (logInfo . displayBytesUtf8) -- Generate the markup. void $ proc "hpc" ( "markup" : toFilePath tixSrc : ("--destdir=" ++ toFilePathNoTrailingSep reportDir) : (args ++ extraMarkupArgs) ) readProcess_ return (Just reportPath) data HpcReportOpts = HpcReportOpts { hroptsInputs :: [Text] , hroptsAll :: Bool , hroptsDestDir :: Maybe String , hroptsOpenBrowser :: Bool } deriving (Show) generateHpcReportForTargets :: HasEnvConfig env => HpcReportOpts -> RIO env () generateHpcReportForTargets opts = do let (tixFiles, targetNames) = partition (".tix" `T.isSuffixOf`) (hroptsInputs opts) targetTixFiles <- -- When there aren't any package component arguments, and --all -- isn't passed, default to not considering any targets. if not (hroptsAll opts) && null targetNames then return [] else do when (hroptsAll opts && not (null targetNames)) $ logWarn $ "Since --all is used, it is redundant to specify these targets: " <> displayShow targetNames (_,_,targets) <- parseTargets AllowNoTargets defaultBuildOptsCLI { boptsCLITargets = if hroptsAll opts then [] else targetNames } liftM concat $ forM (Map.toList targets) $ \(name, target) -> case target of TargetAll Dependency -> throwString $ "Error: Expected a local package, but " ++ packageNameString name ++ " is either an extra-dep or in the snapshot." TargetComps comps -> do pkgPath <- hpcPkgPath name forM (toList comps) $ \nc -> case nc of CTest testName -> liftM (pkgPath ) $ parseRelFile (T.unpack testName ++ "/" ++ T.unpack testName ++ ".tix") _ -> fail $ "Can't specify anything except test-suites as hpc report targets (" ++ packageNameString name ++ " is used with a non test-suite target)" TargetAll ProjectPackage -> do pkgPath <- hpcPkgPath name exists <- doesDirExist pkgPath if exists then do (dirs, _) <- listDir pkgPath liftM concat $ forM dirs $ \dir -> do (_, files) <- listDir dir return (filter ((".tix" `isSuffixOf`) . toFilePath) files) else return [] tixPaths <- liftM (\xs -> xs ++ targetTixFiles) $ mapM (resolveFile' . T.unpack) tixFiles when (null tixPaths) $ throwString "Not generating combined report, because no targets or tix files are specified." outputDir <- hpcReportDir reportDir <- case hroptsDestDir opts of Nothing -> return (outputDir $(mkRelDir "combined/custom")) Just destDir -> do dest <- resolveDir' destDir ensureDir dest return dest let report = "combined report" mreportPath <- generateUnionReport report reportDir tixPaths forM_ mreportPath $ \reportPath -> if hroptsOpenBrowser opts then do prettyInfo $ "Opening" <+> display reportPath <+> "in the browser." void $ liftIO $ openBrowser (toFilePath reportPath) else displayReportPath report (display reportPath) generateHpcUnifiedReport :: HasEnvConfig env => RIO env () generateHpcUnifiedReport = do outputDir <- hpcReportDir ensureDir outputDir (dirs, _) <- listDir outputDir tixFiles0 <- liftM (concat . concat) $ forM (filter (("combined" /=) . dirnameString) dirs) $ \dir -> do (dirs', _) <- listDir dir forM dirs' $ \dir' -> do (_, files) <- listDir dir' return (filter ((".tix" `isSuffixOf`) . toFilePath) files) extraTixFiles <- findExtraTixFiles let tixFiles = tixFiles0 ++ extraTixFiles reportDir = outputDir $(mkRelDir "combined/all") if length tixFiles < 2 then logInfo $ (if null tixFiles then "No tix files" else "Only one tix file") <> " found in " <> fromString (toFilePath outputDir) <> ", so not generating a unified coverage report." else do let report = "unified report" mreportPath <- generateUnionReport report reportDir tixFiles forM_ mreportPath (displayReportPath report . display) generateUnionReport :: HasEnvConfig env => Text -> Path Abs Dir -> [Path Abs File] -> RIO env (Maybe (Path Abs File)) generateUnionReport report reportDir tixFiles = do (errs, tix) <- fmap (unionTixes . map removeExeModules) (mapMaybeM readTixOrLog tixFiles) logDebug $ "Using the following tix files: " <> fromString (show tixFiles) unless (null errs) $ logWarn $ "The following modules are left out of the " <> RIO.display report <> " due to version mismatches: " <> mconcat (intersperse ", " (map fromString errs)) tixDest <- liftM (reportDir ) $ parseRelFile (dirnameString reportDir ++ ".tix") ensureDir (parent tixDest) liftIO $ writeTix (toFilePath tixDest) tix generateHpcReportInternal tixDest reportDir report [] [] readTixOrLog :: HasLogFunc env => Path b File -> RIO env (Maybe Tix) readTixOrLog path = do mtix <- liftIO (readTix (toFilePath path)) `catchAny` \errorCall -> do logError $ "Error while reading tix: " <> fromString (show errorCall) return Nothing when (isNothing mtix) $ logError $ "Failed to read tix file " <> fromString (toFilePath path) return mtix -- | Module names which contain '/' have a package name, and so they weren't built into the -- executable. removeExeModules :: Tix -> Tix removeExeModules (Tix ms) = Tix (filter (\(TixModule name _ _ _) -> '/' `elem` name) ms) unionTixes :: [Tix] -> ([String], Tix) unionTixes tixes = (Map.keys errs, Tix (Map.elems outputs)) where (errs, outputs) = Map.mapEither id $ Map.unionsWith merge $ map toMap tixes toMap (Tix ms) = Map.fromList (map (\x@(TixModule k _ _ _) -> (k, Right x)) ms) merge (Right (TixModule k hash1 len1 tix1)) (Right (TixModule _ hash2 len2 tix2)) | hash1 == hash2 && len1 == len2 = Right (TixModule k hash1 len1 (zipWith (+) tix1 tix2)) merge _ _ = Left () generateHpcMarkupIndex :: HasEnvConfig env => RIO env () generateHpcMarkupIndex = do outputDir <- hpcReportDir let outputFile = outputDir $(mkRelFile "index.html") ensureDir outputDir (dirs, _) <- listDir outputDir rows <- liftM (catMaybes . concat) $ forM dirs $ \dir -> do (subdirs, _) <- listDir dir forM subdirs $ \subdir -> do let indexPath = subdir $(mkRelFile "hpc_index.html") exists' <- doesFileExist indexPath if not exists' then return Nothing else do relPath <- stripProperPrefix outputDir indexPath let package = dirname dir testsuite = dirname subdir return $ Just $ T.concat [ "" , pathToHtml package , "" , pathToHtml testsuite , "" ] liftIO $ T.writeFile (toFilePath outputFile) $ T.concat $ [ "" -- Part of the css from HPC's output HTML , "" , "" , "" ] ++ (if null rows then [ "No hpc_index.html files found in \"" , pathToHtml outputDir , "\"." ] else [ "" , "

NOTE: This is merely a listing of the html files found in the coverage reports directory. Some of these reports may be old.

" , "" ] ++ rows ++ ["
PackageTestSuiteModification Time
"]) ++ [""] unless (null rows) $ logInfo $ "\nAn index of the generated HTML coverage reports is available at " <> fromString (toFilePath outputFile) generateHpcErrorReport :: MonadIO m => Path Abs Dir -> Utf8Builder -> m () generateHpcErrorReport dir err = do ensureDir dir let fp = toFilePath (dir $(mkRelFile "hpc_index.html")) writeFileUtf8Builder fp $ "" <> "

HPC Report Generation Error

" <> "

" <> err <> "

" <> "" pathToHtml :: Path b t -> Text pathToHtml = T.dropWhileEnd (=='/') . sanitize . toFilePath -- | Escape HTML symbols (copied from Text.Hastache) htmlEscape :: LT.Text -> LT.Text htmlEscape = LT.concatMap proc_ where proc_ '&' = "&" proc_ '\\' = "\" proc_ '"' = """ proc_ '\'' = "'" proc_ '<' = "<" proc_ '>' = ">" proc_ h = LT.singleton h sanitize :: String -> Text sanitize = LT.toStrict . htmlEscape . LT.pack dirnameString :: Path r Dir -> String dirnameString = dropWhileEnd isPathSeparator . toFilePath . dirname findPackageFieldForBuiltPackage :: HasEnvConfig env => Path Abs Dir -> PackageIdentifier -> Set.Set Text -> Text -> RIO env (Either Text [Text]) findPackageFieldForBuiltPackage pkgDir pkgId internalLibs field = do distDir <- distDirFromDir pkgDir let inplaceDir = distDir $(mkRelDir "package.conf.inplace") pkgIdStr = packageIdentifierString pkgId notFoundErr = return $ Left $ "Failed to find package key for " <> T.pack pkgIdStr extractField path = do contents <- liftIO $ T.readFile (toFilePath path) case asum (map (T.stripPrefix (field <> ": ")) (T.lines contents)) of Just result -> return $ Right result Nothing -> notFoundErr cabalVer <- view cabalVersionL if cabalVer < $(mkVersion "1.24") then do -- here we don't need to handle internal libs path <- liftM (inplaceDir ) $ parseRelFile (pkgIdStr ++ "-inplace.conf") logDebug $ "Parsing config in Cabal < 1.24 location: " <> fromString (toFilePath path) exists <- doesFileExist path if exists then fmap (:[]) <$> extractField path else notFoundErr else do -- With Cabal-1.24, it's in a different location. logDebug $ "Scanning " <> fromString (toFilePath inplaceDir) <> " for files matching " <> fromString pkgIdStr (_, files) <- handleIO (const $ return ([], [])) $ listDir inplaceDir logDebug $ displayShow files -- From all the files obtained from the scanning process above, we -- need to identify which are .conf files and then ensure that -- there is at most one .conf file for each library and internal -- library (some might be missing if that component has not been -- built yet). We should error if there are more than one .conf -- file for a component or if there are no .conf files at all in -- the searched location. let toFilename = T.pack . toFilePath . filename -- strip known prefix and suffix from the found files to determine only the conf files stripKnown = T.stripSuffix ".conf" <=< T.stripPrefix (T.pack (pkgIdStr ++ "-")) stripped = mapMaybe (\file -> fmap (,file) . stripKnown . toFilename $ file) files -- which component could have generated each of these conf files stripHash n = let z = T.dropWhile (/= '-') n in if T.null z then "" else T.tail z matchedComponents = map (\(n, f) -> (stripHash n, [f])) stripped byComponents = Map.restrictKeys (Map.fromListWith (++) matchedComponents) $ Set.insert "" internalLibs logDebug $ displayShow byComponents if Map.null $ Map.filter (\fs -> length fs > 1) byComponents then case concat $ Map.elems byComponents of [] -> notFoundErr -- for each of these files, we need to extract the requested field paths -> do (errors, keys) <- partitionEithers <$> traverse extractField paths case errors of (a:_) -> return $ Left a -- the first error only, since they're repeated anyway [] -> return $ Right keys else return $ Left $ "Multiple files matching " <> T.pack (pkgIdStr ++ "-*.conf") <> " found in " <> T.pack (toFilePath inplaceDir) <> ". Maybe try 'stack clean' on this package?" displayReportPath :: (HasRunner env) => Text -> AnsiDoc -> RIO env () displayReportPath report reportPath = prettyInfo $ "The" <+> fromString (T.unpack report) <+> "is available at" <+> reportPath findExtraTixFiles :: HasEnvConfig env => RIO env [Path Abs File] findExtraTixFiles = do outputDir <- hpcReportDir let dir = outputDir $(mkRelDir "extra-tix-files") dirExists <- doesDirExist dir if dirExists then do (_, files) <- listDir dir return $ filter ((".tix" `isSuffixOf`) . toFilePath) files else return [] stack-1.9.3.1/src/windows/Stack/DefaultColorWhen.hs0000644000000000000000000000465613455617610020270 0ustar0000000000000000{-# LANGUAGE CPP #-} {- | This version of the module is only for Windows operating systems. -} module Stack.DefaultColorWhen ( defaultColorWhen ) where -- The Win32 package provides CPP macro WINDOWS_CCONV. #include "windows_cconv.h" import Stack.Prelude (stdout) import Stack.Types.Runner (ColorWhen (ColorAuto, ColorNever)) import Data.Bits ((.|.), (.&.)) import Foreign.Marshal (alloca) import Foreign.Ptr (Ptr) import Foreign.Storable (peek) import System.Win32.Types (BOOL, DWORD, HANDLE, iNVALID_HANDLE_VALUE, nullHANDLE, withHandleToHANDLE) defaultColorWhen :: IO ColorWhen defaultColorWhen = withHandleToHANDLE stdout aNSISupport -- The following is based on extracts from the modules -- System.Console.ANSI.Windows.Foreign and System.Console.ANSI.Windows.Detect -- from the ansi-terminal package, simplified. -- | This function first checks if the Windows handle is valid and yields -- 'never' if it is not. It then tries to get a ConHost console mode for that -- handle. If it can not, it assumes that the handle is ANSI-enabled. If virtual -- termimal (VT) processing is already enabled, the handle supports 'auto'. -- Otherwise, it trys to enable processing. If it can, the handle supports -- 'auto'. If it can not, the function yields 'never'. aNSISupport :: HANDLE -> IO ColorWhen aNSISupport h = if h == iNVALID_HANDLE_VALUE || h == nullHANDLE then return ColorNever -- Invalid handle or no handle else do tryMode <- getConsoleMode h case tryMode of Nothing -> return ColorAuto -- No ConHost mode Just mode -> if mode .&. eNABLE_VIRTUAL_TERMINAL_PROCESSING /= 0 then return ColorAuto -- VT processing already enabled else do let mode' = mode .|. eNABLE_VIRTUAL_TERMINAL_PROCESSING succeeded <- cSetConsoleMode h mode' if succeeded then return ColorAuto -- VT processing enabled else return ColorNever -- Can't enable VT processing where eNABLE_VIRTUAL_TERMINAL_PROCESSING = 4 foreign import WINDOWS_CCONV unsafe "windows.h GetConsoleMode" cGetConsoleMode :: HANDLE -> Ptr DWORD -> IO BOOL foreign import WINDOWS_CCONV unsafe "windows.h SetConsoleMode" cSetConsoleMode :: HANDLE -> DWORD -> IO BOOL getConsoleMode :: HANDLE -> IO (Maybe DWORD) getConsoleMode handle = alloca $ \ptr_mode -> do succeeded <- cGetConsoleMode handle ptr_mode if succeeded then Just <$> peek ptr_mode else pure Nothing stack-1.9.3.1/src/unix/Stack/DefaultColorWhen.hs0000644000000000000000000000042313455617610017545 0ustar0000000000000000{- | This version of the module is only for non-Windows (eg unix-like) operating systems. -} module Stack.DefaultColorWhen ( defaultColorWhen ) where import Stack.Types.Runner (ColorWhen (ColorAuto)) defaultColorWhen :: IO ColorWhen defaultColorWhen = return ColorAuto stack-1.9.3.1/src/Stack/Docker.hs0000644000000000000000000012100613455671116014566 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude #-} {-# LANGUAGE CPP, ConstraintKinds, DeriveDataTypeable, FlexibleContexts, MultiWayIf, NamedFieldPuns, OverloadedStrings, PackageImports, RankNTypes, RecordWildCards, ScopedTypeVariables, TemplateHaskell, TupleSections #-} -- | Run commands in Docker containers module Stack.Docker (cleanup ,CleanupOpts(..) ,CleanupAction(..) ,dockerCleanupCmdName ,dockerCmdName ,dockerHelpOptName ,dockerPullCmdName ,entrypoint ,preventInContainer ,pull ,reexecWithOptionalContainer ,reset ,reExecArgName ,StackDockerException(..) ) where import Stack.Prelude import Control.Monad.Writer (execWriter,runWriter,tell) import qualified Crypto.Hash as Hash (Digest, MD5, hash) import Data.Aeson.Extended (FromJSON(..),(.:),(.:?),(.!=),eitherDecode) import Data.ByteString.Builder (stringUtf8,charUtf8,toLazyByteString) import qualified Data.ByteString.Char8 as BS import qualified Data.ByteString.Lazy as BL import qualified Data.ByteString.Lazy.Char8 as LBS import Data.Char (isSpace,toUpper,isAscii,isDigit) import Data.Conduit.List (sinkNull) import Data.Conduit.Process.Typed hiding (proc) import Data.List (dropWhileEnd,intercalate,isPrefixOf,isInfixOf) import Data.List.Extra (trim) import qualified Data.Map.Strict as Map import Data.Ord (Down(..)) import Data.Streaming.Process (ProcessExitedUnsuccessfully(..)) import qualified Data.Text as T import qualified Data.Text.Encoding as T import Data.Time (UTCTime,LocalTime(..),diffDays,utcToLocalTime,getZonedTime,ZonedTime(..)) import Data.Version (showVersion) import GHC.Exts (sortWith) import Lens.Micro (set) import Path import Path.Extra (toFilePathNoTrailingSep) import Path.IO hiding (canonicalizePath) import qualified Paths_stack as Meta import Stack.Config (getInContainer) import Stack.Constants import Stack.Constants.Config import Stack.Docker.GlobalDB import Stack.PackageIndex import Stack.Types.PackageIndex import Stack.Types.Runner import Stack.Types.Version import Stack.Types.Config import Stack.Types.Docker import Stack.Setup (ensureDockerStackExe) import System.Directory (canonicalizePath,getHomeDirectory) import System.Environment (getEnv,getEnvironment,getProgName,getArgs,getExecutablePath) import System.Exit (exitSuccess, exitWith, ExitCode(..)) import qualified System.FilePath as FP import System.IO (stderr,stdin,stdout) import System.IO.Error (isDoesNotExistError) import System.IO.Unsafe (unsafePerformIO) import qualified System.PosixCompat.User as User import qualified System.PosixCompat.Files as Files import System.Process.PagerEditor (editByteString) import RIO.Process import Text.Printf (printf) #ifndef WINDOWS import System.Posix.Signals import qualified System.Posix.User as PosixUser #endif -- | If Docker is enabled, re-runs the currently running OS command in a Docker container. -- Otherwise, runs the inner action. -- -- This takes an optional release action which should be taken IFF control is -- transferring away from the current process to the intra-container one. The main use -- for this is releasing a lock. After launching reexecution, the host process becomes -- nothing but an manager for the call into docker and thus may not hold the lock. reexecWithOptionalContainer :: HasConfig env => Maybe (Path Abs Dir) -> Maybe (RIO env ()) -> IO () -> Maybe (RIO env ()) -> Maybe (RIO env ()) -> RIO env () reexecWithOptionalContainer mprojectRoot = execWithOptionalContainer mprojectRoot getCmdArgs where getCmdArgs docker imageInfo isRemoteDocker = do config <- view configL deUser <- if fromMaybe (not isRemoteDocker) (dockerSetUser docker) then liftIO $ do duUid <- User.getEffectiveUserID duGid <- User.getEffectiveGroupID duGroups <- nubOrd <$> User.getGroups duUmask <- Files.setFileCreationMask 0o022 -- Only way to get old umask seems to be to change it, so set it back afterward _ <- Files.setFileCreationMask duUmask return (Just DockerUser{..}) else return Nothing args <- fmap (["--" ++ reExecArgName ++ "=" ++ showVersion Meta.version ,"--" ++ dockerEntrypointArgName ,show DockerEntrypoint{..}] ++) (liftIO getArgs) case dockerStackExe (configDocker config) of Just DockerStackExeHost | configPlatform config == dockerContainerPlatform -> do exePath <- liftIO getExecutablePath cmdArgs args exePath | otherwise -> throwIO UnsupportedStackExeHostPlatformException Just DockerStackExeImage -> do progName <- liftIO getProgName return (FP.takeBaseName progName, args, [], []) Just (DockerStackExePath path) -> do exePath <- liftIO $ canonicalizePath (toFilePath path) cmdArgs args exePath Just DockerStackExeDownload -> exeDownload args Nothing | configPlatform config == dockerContainerPlatform -> do (exePath,exeTimestamp,misCompatible) <- liftIO $ do exePath <- liftIO getExecutablePath exeTimestamp <- resolveFile' exePath >>= getModificationTime isKnown <- liftIO $ getDockerImageExe config (iiId imageInfo) exePath exeTimestamp return (exePath, exeTimestamp, isKnown) case misCompatible of Just True -> cmdArgs args exePath Just False -> exeDownload args Nothing -> do e <- try $ sinkProcessStderrStdout "docker" [ "run" , "-v" , exePath ++ ":" ++ "/tmp/stack" , iiId imageInfo , "/tmp/stack" , "--version"] sinkNull sinkNull let compatible = case e of Left (ProcessExitedUnsuccessfully _ _) -> False Right _ -> True liftIO $ setDockerImageExe config (iiId imageInfo) exePath exeTimestamp compatible if compatible then cmdArgs args exePath else exeDownload args Nothing -> exeDownload args exeDownload args = do exePath <- ensureDockerStackExe dockerContainerPlatform cmdArgs args (toFilePath exePath) cmdArgs args exePath = do let mountPath = hostBinDir FP. FP.takeBaseName exePath return (mountPath, args, [], [Mount exePath mountPath]) -- | If Docker is enabled, re-runs the OS command returned by the second argument in a -- Docker container. Otherwise, runs the inner action. -- -- This takes an optional release action just like `reexecWithOptionalContainer`. execWithOptionalContainer :: HasConfig env => Maybe (Path Abs Dir) -> GetCmdArgs env -> Maybe (RIO env ()) -> IO () -> Maybe (RIO env ()) -> Maybe (RIO env ()) -> RIO env () execWithOptionalContainer mprojectRoot getCmdArgs mbefore inner mafter mrelease = do config <- view configL inContainer <- getInContainer isReExec <- view reExecL if | inContainer && not isReExec && (isJust mbefore || isJust mafter) -> throwIO OnlyOnHostException | inContainer -> liftIO (do inner System.Exit.exitSuccess) | not (dockerEnable (configDocker config)) -> do fromMaybeAction mbefore liftIO inner fromMaybeAction mafter liftIO System.Exit.exitSuccess | otherwise -> do fromMaybeAction mrelease runContainerAndExit getCmdArgs mprojectRoot (fromMaybeAction mbefore) (fromMaybeAction mafter) where fromMaybeAction Nothing = return () fromMaybeAction (Just hook) = hook -- | Error if running in a container. preventInContainer :: MonadIO m => m () -> m () preventInContainer inner = do inContainer <- getInContainer if inContainer then throwIO OnlyOnHostException else inner -- | Run a command in a new Docker container, then exit the process. runContainerAndExit :: HasConfig env => GetCmdArgs env -> Maybe (Path Abs Dir) -- ^ Project root (maybe) -> RIO env () -- ^ Action to run before -> RIO env () -- ^ Action to run after -> RIO env () runContainerAndExit getCmdArgs mprojectRoot before after = do config <- view configL let docker = configDocker config checkDockerVersion docker (env,isStdinTerminal,isStderrTerminal,homeDir) <- liftIO $ (,,,) <$> getEnvironment <*> hIsTerminalDeviceOrMinTTY stdin <*> hIsTerminalDeviceOrMinTTY stderr <*> (parseAbsDir =<< getHomeDirectory) isStdoutTerminal <- view terminalL let dockerHost = lookup "DOCKER_HOST" env dockerCertPath = lookup "DOCKER_CERT_PATH" env bamboo = lookup "bamboo_buildKey" env jenkins = lookup "JENKINS_HOME" env msshAuthSock = lookup "SSH_AUTH_SOCK" env muserEnv = lookup "USER" env isRemoteDocker = maybe False (isPrefixOf "tcp://") dockerHost image = dockerImage docker when (isRemoteDocker && maybe False (isInfixOf "boot2docker") dockerCertPath) (logWarn "Warning: Using boot2docker is NOT supported, and not likely to perform well.") maybeImageInfo <- inspect image imageInfo@Inspect{..} <- case maybeImageInfo of Just ii -> return ii Nothing | dockerAutoPull docker -> do pullImage docker image mii2 <- inspect image case mii2 of Just ii2 -> return ii2 Nothing -> throwM (InspectFailedException image) | otherwise -> throwM (NotPulledException image) sandboxDir <- projectDockerSandboxDir projectRoot let ImageConfig {..} = iiConfig imageEnvVars = map (break (== '=')) icEnv platformVariant = show $ hashRepoName image stackRoot = view stackRootL config sandboxHomeDir = sandboxDir homeDirName isTerm = not (dockerDetach docker) && isStdinTerminal && isStdoutTerminal && isStderrTerminal keepStdinOpen = not (dockerDetach docker) && -- Workaround for https://github.com/docker/docker/issues/12319 -- This is fixed in Docker 1.9.1, but will leave the workaround -- in place for now, for users who haven't upgraded yet. (isTerm || (isNothing bamboo && isNothing jenkins)) hostBinDirPath <- parseAbsDir hostBinDir newPathEnv <- either throwM return $ augmentPath ( toFilePath <$> [ hostBinDirPath , sandboxHomeDir $(mkRelDir ".local/bin")]) (T.pack <$> lookupImageEnv "PATH" imageEnvVars) (cmnd,args,envVars,extraMount) <- getCmdArgs docker imageInfo isRemoteDocker pwd <- getCurrentDir liftIO (do updateDockerImageLastUsed config iiId (toFilePath projectRoot) mapM_ ensureDir [sandboxHomeDir, stackRoot]) -- Since $HOME is now mounted in the same place in the container we can -- just symlink $HOME/.ssh to the right place for the stack docker user let sshDir = homeDir sshRelDir sshDirExists <- doesDirExist sshDir sshSandboxDirExists <- liftIO (Files.fileExist (toFilePathNoTrailingSep (sandboxHomeDir sshRelDir))) when (sshDirExists && not sshSandboxDirExists) (liftIO (Files.createSymbolicLink (toFilePathNoTrailingSep sshDir) (toFilePathNoTrailingSep (sandboxHomeDir sshRelDir)))) containerID <- withWorkingDir (toFilePath projectRoot) $ trim . decodeUtf8 <$> readDockerProcess (concat [["create" ,"--net=host" ,"-e",inContainerEnvVar ++ "=1" ,"-e",stackRootEnvVar ++ "=" ++ toFilePathNoTrailingSep stackRoot ,"-e",platformVariantEnvVar ++ "=dk" ++ platformVariant ,"-e","HOME=" ++ toFilePathNoTrailingSep sandboxHomeDir ,"-e","PATH=" ++ T.unpack newPathEnv ,"-e","PWD=" ++ toFilePathNoTrailingSep pwd ,"-v",toFilePathNoTrailingSep homeDir ++ ":" ++ toFilePathNoTrailingSep homeDir ,"-v",toFilePathNoTrailingSep stackRoot ++ ":" ++ toFilePathNoTrailingSep stackRoot ,"-v",toFilePathNoTrailingSep projectRoot ++ ":" ++ toFilePathNoTrailingSep projectRoot ,"-v",toFilePathNoTrailingSep sandboxHomeDir ++ ":" ++ toFilePathNoTrailingSep sandboxHomeDir ,"-w",toFilePathNoTrailingSep pwd] ,case muserEnv of Nothing -> [] Just userEnv -> ["-e","USER=" ++ userEnv] ,case msshAuthSock of Nothing -> [] Just sshAuthSock -> ["-e","SSH_AUTH_SOCK=" ++ sshAuthSock ,"-v",sshAuthSock ++ ":" ++ sshAuthSock] -- Disable the deprecated entrypoint in FP Complete-generated images ,["--entrypoint=/usr/bin/env" | isJust (lookupImageEnv oldSandboxIdEnvVar imageEnvVars) && (icEntrypoint == ["/usr/local/sbin/docker-entrypoint"] || icEntrypoint == ["/root/entrypoint.sh"])] ,concatMap (\(k,v) -> ["-e", k ++ "=" ++ v]) envVars ,concatMap mountArg (extraMount ++ dockerMount docker) ,concatMap (\nv -> ["-e", nv]) (dockerEnv docker) ,case dockerContainerName docker of Just name -> ["--name=" ++ name] Nothing -> [] ,["-t" | isTerm] ,["-i" | keepStdinOpen] ,dockerRunArgs docker ,[image] ,[cmnd] ,args]) before #ifndef WINDOWS run <- askRunInIO oldHandlers <- forM [sigINT,sigABRT,sigHUP,sigPIPE,sigTERM,sigUSR1,sigUSR2] $ \sig -> do let sigHandler = run $ do readProcessNull "docker" ["kill","--signal=" ++ show sig,containerID] when (sig `elem` [sigTERM,sigABRT]) $ do -- Give the container 30 seconds to exit gracefully, then send a sigKILL to force it threadDelay 30000000 readProcessNull "docker" ["kill",containerID] oldHandler <- liftIO $ installHandler sig (Catch sigHandler) Nothing return (sig, oldHandler) #endif let args' = concat [["start"] ,["-a" | not (dockerDetach docker)] ,["-i" | keepStdinOpen] ,[containerID]] e <- try (proc "docker" args' $ runProcess_ . setDelegateCtlc False) `finally` (do unless (dockerPersist docker || dockerDetach docker) $ readProcessNull "docker" ["rm","-f",containerID] `catch` (\(_::ExitCodeException) -> return ()) #ifndef WINDOWS forM_ oldHandlers $ \(sig,oldHandler) -> liftIO $ installHandler sig oldHandler Nothing #endif ) case e of Left (ProcessExitedUnsuccessfully _ ec) -> liftIO (System.Exit.exitWith ec) Right () -> do after liftIO System.Exit.exitSuccess where -- This is using a hash of the Docker repository (without tag or digest) to ensure -- binaries/libraries aren't shared between Docker and host (or incompatible Docker images) hashRepoName :: String -> Hash.Digest Hash.MD5 hashRepoName = Hash.hash . BS.pack . takeWhile (\c -> c /= ':' && c /= '@') lookupImageEnv name vars = case lookup name vars of Just ('=':val) -> Just val _ -> Nothing mountArg (Mount host container) = ["-v",host ++ ":" ++ container] projectRoot = fromMaybeProjectRoot mprojectRoot sshRelDir = $(mkRelDir ".ssh/") -- | Clean-up old docker images and containers. cleanup :: HasConfig env => CleanupOpts -> RIO env () cleanup opts = do config <- view configL let docker = configDocker config checkDockerVersion docker imagesOut <- readDockerProcess ["images","--no-trunc","-f","dangling=false"] danglingImagesOut <- readDockerProcess ["images","--no-trunc","-f","dangling=true"] runningContainersOut <- readDockerProcess ["ps","-a","--no-trunc","-f","status=running"] restartingContainersOut <- readDockerProcess ["ps","-a","--no-trunc","-f","status=restarting"] exitedContainersOut <- readDockerProcess ["ps","-a","--no-trunc","-f","status=exited"] pausedContainersOut <- readDockerProcess ["ps","-a","--no-trunc","-f","status=paused"] let imageRepos = parseImagesOut imagesOut danglingImageHashes = Map.keys (parseImagesOut danglingImagesOut) runningContainers = parseContainersOut runningContainersOut ++ parseContainersOut restartingContainersOut stoppedContainers = parseContainersOut exitedContainersOut ++ parseContainersOut pausedContainersOut inspectMap <- inspects (Map.keys imageRepos ++ danglingImageHashes ++ map fst stoppedContainers ++ map fst runningContainers) (imagesLastUsed,curTime) <- liftIO ((,) <$> getDockerImagesLastUsed config <*> getZonedTime) let planWriter = buildPlan curTime imagesLastUsed imageRepos danglingImageHashes stoppedContainers runningContainers inspectMap plan = toLazyByteString (execWriter planWriter) plan' <- case dcAction opts of CleanupInteractive -> liftIO (editByteString (intercalate "-" [stackProgName ,dockerCmdName ,dockerCleanupCmdName ,"plan"]) plan) CleanupImmediate -> return plan CleanupDryRun -> do liftIO (LBS.hPut stdout plan) return LBS.empty mapM_ performPlanLine (reverse (filter filterPlanLine (lines (LBS.unpack plan')))) allImageHashesOut <- readDockerProcess ["images","-aq","--no-trunc"] liftIO (pruneDockerImagesLastUsed config (lines (decodeUtf8 allImageHashesOut))) where filterPlanLine line = case line of c:_ | isSpace c -> False _ -> True performPlanLine line = case filter (not . null) (words (takeWhile (/= '#') line)) of [] -> return () (c:_):t:v:_ -> do args <- if | toUpper c == 'R' && t == imageStr -> do logInfo $ "Removing image: '" <> fromString v <> "'" return ["rmi",v] | toUpper c == 'R' && t == containerStr -> do logInfo $ "Removing container: '" <> fromString v <> "'" return ["rm","-f",v] | otherwise -> throwM (InvalidCleanupCommandException line) e <- try (readDockerProcess args) case e of Left ex -> logError $ "Could not remove: '" <> fromString v <> "': " <> displayShow (ex :: ExitCodeException) Right _ -> return () _ -> throwM (InvalidCleanupCommandException line) parseImagesOut = Map.fromListWith (++) . map parseImageRepo . drop 1 . lines . decodeUtf8 where parseImageRepo :: String -> (String, [String]) parseImageRepo line = case words line of repo:tag:hash:_ | repo == "" -> (hash,[]) | tag == "" -> (hash,[repo]) | otherwise -> (hash,[repo ++ ":" ++ tag]) _ -> impureThrow (InvalidImagesOutputException line) parseContainersOut = map parseContainer . drop 1 . lines . decodeUtf8 where parseContainer line = case words line of hash:image:rest | last:_ <- reverse rest -> (hash,(image,last)) _ -> impureThrow (InvalidPSOutputException line) buildPlan curTime imagesLastUsed imageRepos danglingImageHashes stoppedContainers runningContainers inspectMap = do case dcAction opts of CleanupInteractive -> do buildStrLn (concat ["# STACK DOCKER CLEANUP PLAN" ,"\n#" ,"\n# When you leave the editor, the lines in this plan will be processed." ,"\n#" ,"\n# Lines that begin with 'R' denote an image or container that will be." ,"\n# removed. You may change the first character to/from 'R' to remove/keep" ,"\n# and image or container that would otherwise be kept/removed." ,"\n#" ,"\n# To cancel the cleanup, delete all lines in this file." ,"\n#" ,"\n# By default, the following images/containers will be removed:" ,"\n#"]) buildDefault dcRemoveKnownImagesLastUsedDaysAgo "Known images last used" buildDefault dcRemoveUnknownImagesCreatedDaysAgo "Unknown images created" buildDefault dcRemoveDanglingImagesCreatedDaysAgo "Dangling images created" buildDefault dcRemoveStoppedContainersCreatedDaysAgo "Stopped containers created" buildDefault dcRemoveRunningContainersCreatedDaysAgo "Running containers created" buildStrLn (concat ["#" ,"\n# The default plan can be adjusted using command-line arguments." ,"\n# Run '" ++ unwords [stackProgName, dockerCmdName, dockerCleanupCmdName] ++ " --help' for details." ,"\n#"]) _ -> buildStrLn (unlines ["# Lines that begin with 'R' denote an image or container that will be." ,"# removed."]) buildSection "KNOWN IMAGES (pulled/used by stack)" imagesLastUsed buildKnownImage buildSection "UNKNOWN IMAGES (not managed by stack)" (sortCreated (Map.toList (foldl' (\m (h,_) -> Map.delete h m) imageRepos imagesLastUsed))) buildUnknownImage buildSection "DANGLING IMAGES (no named references and not depended on by other images)" (sortCreated (map (,()) danglingImageHashes)) buildDanglingImage buildSection "STOPPED CONTAINERS" (sortCreated stoppedContainers) (buildContainer (dcRemoveStoppedContainersCreatedDaysAgo opts)) buildSection "RUNNING CONTAINERS" (sortCreated runningContainers) (buildContainer (dcRemoveRunningContainersCreatedDaysAgo opts)) where buildDefault accessor description = case accessor opts of Just days -> buildStrLn ("# - " ++ description ++ " at least " ++ showDays days ++ ".") Nothing -> return () sortCreated = sortWith (\(_,_,x) -> Down x) . mapMaybe (\(h,r) -> case Map.lookup h inspectMap of Nothing -> Nothing Just ii -> Just (h,r,iiCreated ii)) buildSection sectionHead items itemBuilder = do let (anyWrote,b) = runWriter (forM items itemBuilder) when (or anyWrote) $ do buildSectionHead sectionHead tell b buildKnownImage (imageHash,lastUsedProjects) = case Map.lookup imageHash imageRepos of Just repos@(_:_) -> do case lastUsedProjects of (l,_):_ -> forM_ repos (buildImageTime (dcRemoveKnownImagesLastUsedDaysAgo opts) l) _ -> forM_ repos buildKeepImage forM_ lastUsedProjects buildProject buildInspect imageHash return True _ -> return False buildUnknownImage (hash, repos, created) = case repos of [] -> return False _ -> do forM_ repos (buildImageTime (dcRemoveUnknownImagesCreatedDaysAgo opts) created) buildInspect hash return True buildDanglingImage (hash, (), created) = do buildImageTime (dcRemoveDanglingImagesCreatedDaysAgo opts) created hash buildInspect hash return True buildContainer removeAge (hash,(image,name),created) = do let disp = name ++ " (image: " ++ image ++ ")" buildTime containerStr removeAge created disp buildInspect hash return True buildProject (lastUsedTime, projectPath) = buildInfo ("Last used " ++ showDaysAgo lastUsedTime ++ " in " ++ projectPath) buildInspect hash = case Map.lookup hash inspectMap of Just Inspect{iiCreated,iiVirtualSize} -> buildInfo ("Created " ++ showDaysAgo iiCreated ++ maybe "" (\s -> " (size: " ++ printf "%g" (fromIntegral s / 1024.0 / 1024.0 :: Float) ++ "M)") iiVirtualSize) Nothing -> return () showDays days = case days of 0 -> "today" 1 -> "yesterday" n -> show n ++ " days ago" showDaysAgo oldTime = showDays (daysAgo oldTime) daysAgo oldTime = let ZonedTime (LocalTime today _) zone = curTime LocalTime oldDay _ = utcToLocalTime zone oldTime in diffDays today oldDay buildImageTime = buildTime imageStr buildTime t removeAge time disp = case removeAge of Just d | daysAgo time >= d -> buildStrLn ("R " ++ t ++ " " ++ disp) _ -> buildKeep t disp buildKeep t d = buildStrLn (" " ++ t ++ " " ++ d) buildKeepImage = buildKeep imageStr buildSectionHead s = buildStrLn ("\n#\n# " ++ s ++ "\n#\n") buildInfo = buildStrLn . (" # " ++) buildStrLn l = do buildStr l tell (charUtf8 '\n') buildStr = tell . stringUtf8 imageStr = "image" containerStr = "container" -- | Inspect Docker image or container. inspect :: (HasProcessContext env, HasLogFunc env) => String -> RIO env (Maybe Inspect) inspect image = do results <- inspects [image] case Map.toList results of [] -> return Nothing [(_,i)] -> return (Just i) _ -> throwIO (InvalidInspectOutputException "expect a single result") -- | Inspect multiple Docker images and/or containers. inspects :: (HasProcessContext env, HasLogFunc env) => [String] -> RIO env (Map String Inspect) inspects [] = return Map.empty inspects images = do maybeInspectOut <- try (readDockerProcess ("inspect" : images)) case maybeInspectOut of Right inspectOut -> -- filtering with 'isAscii' to workaround @docker inspect@ output containing invalid UTF-8 case eitherDecode (LBS.pack (filter isAscii (decodeUtf8 inspectOut))) of Left msg -> throwIO (InvalidInspectOutputException msg) Right results -> return (Map.fromList (map (\r -> (iiId r,r)) results)) Left ece | any (`LBS.isPrefixOf` eceStderr ece) missingImagePrefixes -> return Map.empty Left e -> throwIO e where missingImagePrefixes = ["Error: No such image", "Error: No such object:"] -- | Pull latest version of configured Docker image from registry. pull :: HasConfig env => RIO env () pull = do config <- view configL let docker = configDocker config checkDockerVersion docker pullImage docker (dockerImage docker) -- | Pull Docker image from registry. pullImage :: (HasProcessContext env, HasLogFunc env) => DockerOpts -> String -> RIO env () pullImage docker image = do logInfo ("Pulling image from registry: '" <> fromString image <> "'") when (dockerRegistryLogin docker) (do logInfo "You may need to log in." proc "docker" (concat [["login"] ,maybe [] (\n -> ["--username=" ++ n]) (dockerRegistryUsername docker) ,maybe [] (\p -> ["--password=" ++ p]) (dockerRegistryPassword docker) ,[takeWhile (/= '/') image]]) runProcess_) -- We redirect the stdout of the process to stderr so that the output -- of @docker pull@ will not interfere with the output of other -- commands when using --auto-docker-pull. See issue #2733. ec <- proc "docker" ["pull", image] $ \pc0 -> do let pc = setStdout (useHandleOpen stderr) $ setStderr (useHandleOpen stderr) $ setStdin closed pc0 runProcess pc case ec of ExitSuccess -> return () ExitFailure _ -> throwIO (PullFailedException image) -- | Check docker version (throws exception if incorrect) checkDockerVersion :: (HasProcessContext env, HasLogFunc env) => DockerOpts -> RIO env () checkDockerVersion docker = do dockerExists <- doesExecutableExist "docker" unless dockerExists (throwIO DockerNotInstalledException) dockerVersionOut <- readDockerProcess ["--version"] case words (decodeUtf8 dockerVersionOut) of (_:_:v:_) -> case parseVersionFromString (stripVersion v) of Just v' | v' < minimumDockerVersion -> throwIO (DockerTooOldException minimumDockerVersion v') | v' `elem` prohibitedDockerVersions -> throwIO (DockerVersionProhibitedException prohibitedDockerVersions v') | not (v' `withinRange` dockerRequireDockerVersion docker) -> throwIO (BadDockerVersionException (dockerRequireDockerVersion docker) v') | otherwise -> return () _ -> throwIO InvalidVersionOutputException _ -> throwIO InvalidVersionOutputException where minimumDockerVersion = $(mkVersion "1.6.0") prohibitedDockerVersions = [] stripVersion v = takeWhile (/= '-') (dropWhileEnd (not . isDigit) v) -- | Remove the project's Docker sandbox. reset :: (MonadIO m, MonadReader env m, HasConfig env) => Maybe (Path Abs Dir) -> Bool -> m () reset maybeProjectRoot keepHome = do dockerSandboxDir <- projectDockerSandboxDir projectRoot liftIO (removeDirectoryContents dockerSandboxDir [homeDirName | keepHome] []) where projectRoot = fromMaybeProjectRoot maybeProjectRoot -- | The Docker container "entrypoint": special actions performed when first entering -- a container, such as switching the UID/GID to the "outside-Docker" user's. entrypoint :: (HasProcessContext env, HasLogFunc env) => Config -> DockerEntrypoint -> RIO env () entrypoint config@Config{..} DockerEntrypoint{..} = modifyMVar_ entrypointMVar $ \alreadyRan -> do -- Only run the entrypoint once unless alreadyRan $ do envOverride <- view processContextL homeDir <- liftIO $ parseAbsDir =<< getEnv "HOME" -- Get the UserEntry for the 'stack' user in the image, if it exists estackUserEntry0 <- liftIO $ tryJust (guard . isDoesNotExistError) $ User.getUserEntryForName stackUserName -- Switch UID/GID if needed, and update user's home directory case deUser of Nothing -> return () Just (DockerUser 0 _ _ _) -> return () Just du -> withProcessContext envOverride $ updateOrCreateStackUser estackUserEntry0 homeDir du case estackUserEntry0 of Left _ -> return () Right ue -> do -- If the 'stack' user exists in the image, copy any build plans and package indices from -- its original home directory to the host's stack root, to avoid needing to download them origStackHomeDir <- liftIO $ parseAbsDir (User.homeDirectory ue) let origStackRoot = origStackHomeDir $(mkRelDir ("." ++ stackProgName)) buildPlanDirExists <- doesDirExist (buildPlanDir origStackRoot) when buildPlanDirExists $ do (_, buildPlans) <- listDir (buildPlanDir origStackRoot) forM_ buildPlans $ \srcBuildPlan -> do let destBuildPlan = buildPlanDir (view stackRootL config) filename srcBuildPlan exists <- doesFileExist destBuildPlan unless exists $ do ensureDir (parent destBuildPlan) copyFile srcBuildPlan destBuildPlan forM_ clIndices $ \pkgIdx -> do msrcIndex <- runRIO (set stackRootL origStackRoot config) $ do srcIndex <- configPackageIndex (indexName pkgIdx) exists <- doesFileExist srcIndex return $ if exists then Just srcIndex else Nothing case msrcIndex of Nothing -> return () Just srcIndex -> runRIO config $ do destIndex <- configPackageIndex (indexName pkgIdx) exists <- doesFileExist destIndex unless exists $ do ensureDir (parent destIndex) copyFile srcIndex destIndex return True where CabalLoader {..} = configCabalLoader updateOrCreateStackUser estackUserEntry homeDir DockerUser{..} = do case estackUserEntry of Left _ -> do -- If no 'stack' user in image, create one with correct UID/GID and home directory readProcessNull "groupadd" ["-o" ,"--gid",show duGid ,stackUserName] readProcessNull "useradd" ["-oN" ,"--uid",show duUid ,"--gid",show duGid ,"--home",toFilePathNoTrailingSep homeDir ,stackUserName] Right _ -> do -- If there is already a 'stack' user in the image, adjust its UID/GID and home directory readProcessNull "usermod" ["-o" ,"--uid",show duUid ,"--home",toFilePathNoTrailingSep homeDir ,stackUserName] readProcessNull "groupmod" ["-o" ,"--gid",show duGid ,stackUserName] forM_ duGroups $ \gid -> do readProcessNull "groupadd" ["-o" ,"--gid",show gid ,"group" ++ show gid] -- 'setuid' to the wanted UID and GID liftIO $ do User.setGroupID duGid #ifndef WINDOWS PosixUser.setGroups duGroups #endif User.setUserID duUid _ <- Files.setFileCreationMask duUmask return () stackUserName = "stack"::String -- | MVar used to ensure the Docker entrypoint is performed exactly once entrypointMVar :: MVar Bool {-# NOINLINE entrypointMVar #-} entrypointMVar = unsafePerformIO (newMVar False) -- | Remove the contents of a directory, without removing the directory itself. -- This is used instead of 'FS.removeTree' to clear bind-mounted directories, since -- removing the root of the bind-mount won't work. removeDirectoryContents :: Path Abs Dir -- ^ Directory to remove contents of -> [Path Rel Dir] -- ^ Top-level directory names to exclude from removal -> [Path Rel File] -- ^ Top-level file names to exclude from removal -> IO () removeDirectoryContents path excludeDirs excludeFiles = do isRootDir <- doesDirExist path when isRootDir (do (lsd,lsf) <- listDir path forM_ lsd (\d -> unless (dirname d `elem` excludeDirs) (removeDirRecur d)) forM_ lsf (\f -> unless (filename f `elem` excludeFiles) (removeFile f))) -- | Produce a strict 'S.ByteString' from the stdout of a -- process. Throws a 'ReadProcessException' exception if the -- process fails. Logs process's stderr using @logError@. readDockerProcess :: (HasProcessContext env, HasLogFunc env) => [String] -> RIO env BS.ByteString readDockerProcess args = BL.toStrict <$> proc "docker" args readProcessStdout_ -- FIXME stderr isn't logged with logError, should it be? -- | Name of home directory within docker sandbox. homeDirName :: Path Rel Dir homeDirName = $(mkRelDir "_home/") -- | Directory where 'stack' executable is bind-mounted in Docker container hostBinDir :: FilePath hostBinDir = "/opt/host/bin" -- | Convenience function to decode ByteString to String. decodeUtf8 :: BS.ByteString -> String decodeUtf8 bs = T.unpack (T.decodeUtf8 bs) -- | Fail with friendly error if project root not set. fromMaybeProjectRoot :: Maybe (Path Abs Dir) -> Path Abs Dir fromMaybeProjectRoot = fromMaybe (impureThrow CannotDetermineProjectRootException) -- | Environment variable that contained the old sandbox ID. -- | Use of this variable is deprecated, and only used to detect old images. oldSandboxIdEnvVar :: String oldSandboxIdEnvVar = "DOCKER_SANDBOX_ID" -- | Options for 'cleanup'. data CleanupOpts = CleanupOpts { dcAction :: !CleanupAction , dcRemoveKnownImagesLastUsedDaysAgo :: !(Maybe Integer) , dcRemoveUnknownImagesCreatedDaysAgo :: !(Maybe Integer) , dcRemoveDanglingImagesCreatedDaysAgo :: !(Maybe Integer) , dcRemoveStoppedContainersCreatedDaysAgo :: !(Maybe Integer) , dcRemoveRunningContainersCreatedDaysAgo :: !(Maybe Integer) } deriving (Show) -- | Cleanup action. data CleanupAction = CleanupInteractive | CleanupImmediate | CleanupDryRun deriving (Show) -- | Parsed result of @docker inspect@. data Inspect = Inspect {iiConfig :: ImageConfig ,iiCreated :: UTCTime ,iiId :: String ,iiVirtualSize :: Maybe Integer} deriving (Show) -- | Parse @docker inspect@ output. instance FromJSON Inspect where parseJSON v = do o <- parseJSON v Inspect <$> o .: "Config" <*> o .: "Created" <*> o .: "Id" <*> o .:? "VirtualSize" -- | Parsed @Config@ section of @docker inspect@ output. data ImageConfig = ImageConfig {icEnv :: [String] ,icEntrypoint :: [String]} deriving (Show) -- | Parse @Config@ section of @docker inspect@ output. instance FromJSON ImageConfig where parseJSON v = do o <- parseJSON v ImageConfig <$> fmap join (o .:? "Env") .!= [] <*> fmap join (o .:? "Entrypoint") .!= [] -- | Function to get command and arguments to run in Docker container type GetCmdArgs env = DockerOpts -> Inspect -> Bool -> RIO env (FilePath,[String],[(String,String)],[Mount]) stack-1.9.3.1/src/Stack/Docker/GlobalDB.hs0000644000000000000000000001177013455617610016201 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude #-} {-# LANGUAGE QuasiQuotes, TemplateHaskell, TypeFamilies, OverloadedStrings, GADTs, FlexibleContexts, MultiParamTypeClasses, GeneralizedNewtypeDeriving, RankNTypes, NamedFieldPuns #-} -- | Global sqlite database shared by all projects. -- Warning: this is currently only accessible from __outside__ a Docker container. module Stack.Docker.GlobalDB (updateDockerImageLastUsed ,getDockerImagesLastUsed ,pruneDockerImagesLastUsed ,DockerImageLastUsed ,DockerImageProjectId ,getDockerImageExe ,setDockerImageExe ,DockerImageExeId) where import Control.Monad.Logger (NoLoggingT) -- TODO remove dep when persistent drops monad-logger import Control.Monad.Trans.Resource (ResourceT) import Stack.Prelude import Data.List (sortBy, isInfixOf, stripPrefix) import Data.List.Extra (stripSuffix) import qualified Data.Map.Strict as Map import qualified Data.Text as T import Data.Time.Clock (UTCTime,getCurrentTime) import Database.Persist import Database.Persist.Sqlite import Database.Persist.TH import Path (parent, (<.>)) import Path.IO (ensureDir) import Stack.Types.Config import Stack.Types.Docker import System.FileLock (withFileLock, SharedExclusive(Exclusive)) share [mkPersist sqlSettings, mkMigrate "migrateTables"] [persistLowerCase| DockerImageProject imageHash String projectPath FilePath lastUsedTime UTCTime DockerImageProjectPathKey imageHash projectPath deriving Show DockerImageExe imageHash String exePath FilePath exeTimestamp UTCTime compatible Bool DockerImageExeUnique imageHash exePath exeTimestamp deriving Show |] -- | Update last used time and project for a Docker image hash. updateDockerImageLastUsed :: Config -> String -> FilePath -> IO () updateDockerImageLastUsed config imageId projectPath = do curTime <- getCurrentTime _ <- withGlobalDB config (upsert (DockerImageProject imageId projectPath curTime) []) return () -- | Get a list of Docker image hashes and when they were last used. getDockerImagesLastUsed :: Config -> IO [DockerImageLastUsed] getDockerImagesLastUsed config = sortBy (flip sortImage) . Map.toDescList . Map.fromListWith (++) . map mapImageProject <$> withGlobalDB config (selectList [] [Asc DockerImageProjectLastUsedTime]) where mapImageProject (Entity _ imageProject) = (dockerImageProjectImageHash imageProject ,[(dockerImageProjectLastUsedTime imageProject ,dockerImageProjectProjectPath imageProject)]) sortImage (_,(a,_):_) (_,(b,_):_) = compare a b sortImage _ _ = EQ -- | Given a list of all existing Docker images, remove any that no longer exist from -- the database. pruneDockerImagesLastUsed :: Config -> [String] -> IO () pruneDockerImagesLastUsed config existingHashes = withGlobalDB config go where go = do l <- selectList [] [] forM_ l (\(Entity k DockerImageProject{dockerImageProjectImageHash = h}) -> when (h `notElem` existingHashes) $ delete k) -- | Get the record of whether an executable is compatible with a Docker image getDockerImageExe :: Config -> String -> FilePath -> UTCTime -> IO (Maybe Bool) getDockerImageExe config imageId exePath exeTimestamp = withGlobalDB config $ fmap (dockerImageExeCompatible . entityVal) <$> getBy (DockerImageExeUnique imageId exePath exeTimestamp) -- | Seet the record of whether an executable is compatible with a Docker image setDockerImageExe :: Config -> String -> FilePath -> UTCTime -> Bool -> IO () setDockerImageExe config imageId exePath exeTimestamp compatible = withGlobalDB config $ do _ <- upsert (DockerImageExe imageId exePath exeTimestamp compatible) [] return () -- | Run an action with the global database. This performs any needed migrations as well. withGlobalDB :: forall a. Config -> SqlPersistT (NoLoggingT (ResourceT IO)) a -> IO a withGlobalDB config action = do let db = dockerDatabasePath (configDocker config) dbLock <- db <.> "lock" ensureDir (parent db) withFileLock (toFilePath dbLock) Exclusive (\_fl -> runSqlite (T.pack (toFilePath db)) (do _ <- runMigrationSilent migrateTables action)) `catch` \ex -> do let str = show ex str' = fromMaybe str $ stripPrefix "user error (" $ fromMaybe str $ stripSuffix ")" str if "ErrorReadOnly" `isInfixOf` str then throwString $ str' ++ " This likely indicates that your DB file, " ++ toFilePath db ++ ", has incorrect permissions or ownership." else throwIO (ex :: IOException) -- | Date and project path where Docker image hash last used. type DockerImageLastUsed = (String, [(UTCTime, FilePath)]) stack-1.9.3.1/src/Stack/Dot.hs0000644000000000000000000003443413455617610014114 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude #-} {-# LANGUAGE ConstraintKinds #-} {-# LANGUAGE TupleSections #-} {-# LANGUAGE FlexibleContexts #-} {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TemplateHaskell #-} module Stack.Dot (dot ,listDependencies ,DotOpts(..) ,DotPayload(..) ,ListDepsOpts(..) ,resolveDependencies ,printGraph ,pruneGraph ) where import qualified Data.Foldable as F import qualified Data.HashSet as HashSet import qualified Data.Map as Map import qualified Data.Set as Set import qualified Data.Text as Text import qualified Data.Text.IO as Text import qualified Data.Traversable as T import Distribution.Text (display) import qualified Distribution.SPDX.License as SPDX import Distribution.License (License(BSD3), licenseFromSPDX) import Stack.Build (loadPackage) import Stack.Build.Installed (getInstalled, GetInstalledOpts(..)) import Stack.Build.Source import Stack.Build.Target import Stack.Config (getLocalPackages) import Stack.Constants import Stack.Package import Stack.PackageDump (DumpPackage(..)) import Stack.Prelude hiding (Display (..)) import Stack.Types.Build import Stack.Types.BuildPlan import Stack.Types.Config import Stack.Types.FlagName import Stack.Types.GhcPkgId import Stack.Types.Package import Stack.Types.PackageIdentifier import Stack.Types.PackageName import Stack.Types.Version -- | Options record for @stack dot@ data DotOpts = DotOpts { dotIncludeExternal :: !Bool -- ^ Include external dependencies , dotIncludeBase :: !Bool -- ^ Include dependencies on base , dotDependencyDepth :: !(Maybe Int) -- ^ Limit the depth of dependency resolution to (Just n) or continue until fixpoint , dotPrune :: !(Set String) -- ^ Package names to prune from the graph , dotTargets :: [Text] -- ^ stack TARGETs to trace dependencies for , dotFlags :: !(Map (Maybe PackageName) (Map FlagName Bool)) -- ^ Flags to apply when calculating dependencies , dotTestTargets :: Bool -- ^ Like the "--test" flag for build, affects the meaning of 'dotTargets'. , dotBenchTargets :: Bool -- ^ Like the "--bench" flag for build, affects the meaning of 'dotTargets'. } data ListDepsOpts = ListDepsOpts { listDepsDotOpts :: !DotOpts -- ^ The normal dot options. , listDepsSep :: !Text -- ^ Separator between the package name and details. , listDepsLicense :: !Bool -- ^ Print dependency licenses instead of versions. } -- | Visualize the project's dependencies as a graphviz graph dot :: HasEnvConfig env => DotOpts -> RIO env () dot dotOpts = do (localNames, prunedGraph) <- createPrunedDependencyGraph dotOpts printGraph dotOpts localNames prunedGraph -- | Information about a package in the dependency graph, when available. data DotPayload = DotPayload { payloadVersion :: Maybe Version -- ^ The package version. , payloadLicense :: Maybe (Either SPDX.License License) -- ^ The license the package was released under. } deriving (Eq, Show) -- | Create the dependency graph and also prune it as specified in the dot -- options. Returns a set of local names and and a map from package names to -- dependencies. createPrunedDependencyGraph :: HasEnvConfig env => DotOpts -> RIO env (Set PackageName, Map PackageName (Set PackageName, DotPayload)) createPrunedDependencyGraph dotOpts = do localNames <- liftM (Map.keysSet . lpProject) getLocalPackages resultGraph <- createDependencyGraph dotOpts let pkgsToPrune = if dotIncludeBase dotOpts then dotPrune dotOpts else Set.insert "base" (dotPrune dotOpts) prunedGraph = pruneGraph localNames pkgsToPrune resultGraph return (localNames, prunedGraph) -- | Create the dependency graph, the result is a map from a package -- name to a tuple of dependencies and payload if available. This -- function mainly gathers the required arguments for -- @resolveDependencies@. createDependencyGraph :: HasEnvConfig env => DotOpts -> RIO env (Map PackageName (Set PackageName, DotPayload)) createDependencyGraph dotOpts = do (locals, sourceMap) <- loadSourceMap NeedTargets defaultBuildOptsCLI { boptsCLITargets = dotTargets dotOpts , boptsCLIFlags = dotFlags dotOpts } let graph = Map.fromList (localDependencies dotOpts (filter lpWanted locals)) (installedMap, globalDump, _, _) <- getInstalled (GetInstalledOpts False False False) sourceMap -- TODO: Can there be multiple entries for wired-in-packages? If so, -- this will choose one arbitrarily.. let globalDumpMap = Map.fromList $ map (\dp -> (packageIdentifierName (dpPackageIdent dp), dp)) globalDump globalIdMap = Map.fromList $ map (\dp -> (dpGhcPkgId dp, dpPackageIdent dp)) globalDump let depLoader = createDepLoader sourceMap installedMap globalDumpMap globalIdMap loadPackageDeps loadPackageDeps name version loc flags ghcOptions -- Skip packages that can't be loaded - see -- https://github.com/commercialhaskell/stack/issues/2967 | name `elem` [$(mkPackageName "rts"), $(mkPackageName "ghc")] = return (Set.empty, DotPayload (Just version) (Just $ Right BSD3)) | otherwise = fmap (packageAllDeps &&& makePayload) (loadPackage loc flags ghcOptions) resolveDependencies (dotDependencyDepth dotOpts) graph depLoader where makePayload pkg = DotPayload (Just $ packageVersion pkg) (Just $ packageLicense pkg) listDependencies :: HasEnvConfig env => ListDepsOpts -> RIO env () listDependencies opts = do let dotOpts = listDepsDotOpts opts (_, resultGraph) <- createPrunedDependencyGraph dotOpts void (Map.traverseWithKey go (snd <$> resultGraph)) where go name payload = let payloadText = if listDepsLicense opts then maybe "" (Text.pack . display . either licenseFromSPDX id) (payloadLicense payload) else maybe "" (Text.pack . show) (payloadVersion payload) line = packageNameText name <> listDepsSep opts <> payloadText in liftIO $ Text.putStrLn line -- | @pruneGraph dontPrune toPrune graph@ prunes all packages in -- @graph@ with a name in @toPrune@ and removes resulting orphans -- unless they are in @dontPrune@ pruneGraph :: (F.Foldable f, F.Foldable g, Eq a) => f PackageName -> g String -> Map PackageName (Set PackageName, a) -> Map PackageName (Set PackageName, a) pruneGraph dontPrune names = pruneUnreachable dontPrune . Map.mapMaybeWithKey (\pkg (pkgDeps,x) -> if show pkg `F.elem` names then Nothing else let filtered = Set.filter (\n -> show n `F.notElem` names) pkgDeps in if Set.null filtered && not (Set.null pkgDeps) then Nothing else Just (filtered,x)) -- | Make sure that all unreachable nodes (orphans) are pruned pruneUnreachable :: (Eq a, F.Foldable f) => f PackageName -> Map PackageName (Set PackageName, a) -> Map PackageName (Set PackageName, a) pruneUnreachable dontPrune = fixpoint prune where fixpoint :: Eq a => (a -> a) -> a -> a fixpoint f v = if f v == v then v else fixpoint f (f v) prune graph' = Map.filterWithKey (\k _ -> reachable k) graph' where reachable k = k `F.elem` dontPrune || k `Set.member` reachables reachables = F.fold (fst <$> graph') -- | Resolve the dependency graph up to (Just depth) or until fixpoint is reached resolveDependencies :: (Applicative m, Monad m) => Maybe Int -> Map PackageName (Set PackageName, DotPayload) -> (PackageName -> m (Set PackageName, DotPayload)) -> m (Map PackageName (Set PackageName, DotPayload)) resolveDependencies (Just 0) graph _ = return graph resolveDependencies limit graph loadPackageDeps = do let values = Set.unions (fst <$> Map.elems graph) keys = Map.keysSet graph next = Set.difference values keys if Set.null next then return graph else do x <- T.traverse (\name -> (name,) <$> loadPackageDeps name) (F.toList next) resolveDependencies (subtract 1 <$> limit) (Map.unionWith unifier graph (Map.fromList x)) loadPackageDeps where unifier (pkgs1,v1) (pkgs2,_) = (Set.union pkgs1 pkgs2, v1) -- | Given a SourceMap and a dependency loader, load the set of dependencies for a package createDepLoader :: Applicative m => Map PackageName PackageSource -> Map PackageName (InstallLocation, Installed) -> Map PackageName (DumpPackage () () ()) -> Map GhcPkgId PackageIdentifier -> (PackageName -> Version -> PackageLocationIndex FilePath -> Map FlagName Bool -> [Text] -> m (Set PackageName, DotPayload)) -> PackageName -> m (Set PackageName, DotPayload) createDepLoader sourceMap installed globalDumpMap globalIdMap loadPackageDeps pkgName = if not (pkgName `HashSet.member` wiredInPackages) then case Map.lookup pkgName sourceMap of Just (PSFiles lp _) -> pure (packageAllDeps pkg, payloadFromLocal pkg) where pkg = localPackageToPackage lp Just (PSIndex _ flags ghcOptions loc) -> -- FIXME pretty certain this could be cleaned up a lot by including more info in PackageSource let PackageIdentifierRevision (PackageIdentifier name version) _ = loc in assert (pkgName == name) (loadPackageDeps pkgName version (PLIndex loc) flags ghcOptions) Nothing -> pure (Set.empty, payloadFromInstalled (Map.lookup pkgName installed)) -- For wired-in-packages, use information from ghc-pkg (see #3084) else case Map.lookup pkgName globalDumpMap of Nothing -> error ("Invariant violated: Expected to find wired-in-package " ++ packageNameString pkgName ++ " in global DB") Just dp -> pure (Set.fromList deps, payloadFromDump dp) where deps = map (\depId -> maybe (error ("Invariant violated: Expected to find " ++ ghcPkgIdString depId ++ " in global DB")) packageIdentifierName (Map.lookup depId globalIdMap)) (dpDepends dp) where payloadFromLocal pkg = DotPayload (Just $ packageVersion pkg) (Just $ packageLicense pkg) payloadFromInstalled maybePkg = DotPayload (fmap (installedVersion . snd) maybePkg) $ case maybePkg of Just (_, Library _ _ mlicense) -> mlicense _ -> Nothing payloadFromDump dp = DotPayload (Just $ packageIdentifierVersion $ dpPackageIdent dp) (Right <$> dpLicense dp) -- | Resolve the direct (depth 0) external dependencies of the given local packages localDependencies :: DotOpts -> [LocalPackage] -> [(PackageName, (Set PackageName, DotPayload))] localDependencies dotOpts locals = map (\lp -> let pkg = localPackageToPackage lp in (packageName pkg, (deps pkg, lpPayload pkg))) locals where deps pkg = if dotIncludeExternal dotOpts then Set.delete (packageName pkg) (packageAllDeps pkg) else Set.intersection localNames (packageAllDeps pkg) localNames = Set.fromList $ map (packageName . lpPackage) locals lpPayload pkg = DotPayload (Just $ packageVersion pkg) (Just $ packageLicense pkg) -- | Print a graphviz graph of the edges in the Map and highlight the given local packages printGraph :: (Applicative m, MonadIO m) => DotOpts -> Set PackageName -- ^ all locals -> Map PackageName (Set PackageName, DotPayload) -> m () printGraph dotOpts locals graph = do liftIO $ Text.putStrLn "strict digraph deps {" printLocalNodes dotOpts filteredLocals printLeaves graph void (Map.traverseWithKey printEdges (fst <$> graph)) liftIO $ Text.putStrLn "}" where filteredLocals = Set.filter (\local' -> packageNameString local' `Set.notMember` dotPrune dotOpts) locals -- | Print the local nodes with a different style depending on options printLocalNodes :: (F.Foldable t, MonadIO m) => DotOpts -> t PackageName -> m () printLocalNodes dotOpts locals = liftIO $ Text.putStrLn (Text.intercalate "\n" lpNodes) where applyStyle :: Text -> Text applyStyle n = if dotIncludeExternal dotOpts then n <> " [style=dashed];" else n <> " [style=solid];" lpNodes :: [Text] lpNodes = map (applyStyle . nodeName) (F.toList locals) -- | Print nodes without dependencies printLeaves :: MonadIO m => Map PackageName (Set PackageName, DotPayload) -> m () printLeaves = F.mapM_ printLeaf . Map.keysSet . Map.filter Set.null . fmap fst -- | @printDedges p ps@ prints an edge from p to every ps printEdges :: MonadIO m => PackageName -> Set PackageName -> m () printEdges package deps = F.forM_ deps (printEdge package) -- | Print an edge between the two package names printEdge :: MonadIO m => PackageName -> PackageName -> m () printEdge from to' = liftIO $ Text.putStrLn (Text.concat [ nodeName from, " -> ", nodeName to', ";"]) -- | Convert a package name to a graph node name. nodeName :: PackageName -> Text nodeName name = "\"" <> packageNameText name <> "\"" -- | Print a node with no dependencies printLeaf :: MonadIO m => PackageName -> m () printLeaf package = liftIO . Text.putStrLn . Text.concat $ if isWiredIn package then ["{rank=max; ", nodeName package, " [shape=box]; };"] else ["{rank=max; ", nodeName package, "; };"] -- | Check if the package is wired in (shipped with) ghc isWiredIn :: PackageName -> Bool isWiredIn = (`HashSet.member` wiredInPackages) localPackageToPackage :: LocalPackage -> Package localPackageToPackage lp = fromMaybe (lpPackage lp) (lpTestBench lp) stack-1.9.3.1/src/Stack/Fetch.hs0000644000000000000000000007031613455617610014416 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude #-} {-# LANGUAGE ConstraintKinds #-} {-# LANGUAGE DataKinds #-} {-# LANGUAGE DeriveDataTypeable #-} {-# LANGUAGE FlexibleContexts #-} {-# LANGUAGE MultiParamTypeClasses #-} {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE PatternGuards #-} {-# LANGUAGE RankNTypes #-} {-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE TemplateHaskell #-} {-# LANGUAGE TupleSections #-} {-# LANGUAGE TypeFamilies #-} {-# LANGUAGE PackageImports #-} {-# LANGUAGE ViewPatterns #-} {-# LANGUAGE RecordWildCards #-} -- | Functionality for downloading packages securely for cabal's usage. module Stack.Fetch ( unpackPackages , unpackPackageIdent , unpackPackageIdents , fetchPackages , untar , resolvePackages , resolvePackagesAllowMissing , ResolvedPackage (..) , withCabalFiles , loadFromIndex ) where import qualified Codec.Archive.Tar as Tar import qualified Codec.Archive.Tar.Check as Tar import qualified Codec.Archive.Tar.Entry as Tar import Codec.Compression.GZip (decompress) import Stack.Prelude import Crypto.Hash (SHA256 (..)) import qualified Data.ByteString as S import qualified Data.Foldable as F import qualified Data.HashMap.Strict as HashMap import qualified Data.HashSet as HashSet import Data.List (intercalate, maximum) import Data.List.NonEmpty (NonEmpty) import qualified Data.List.NonEmpty as NE import qualified Data.Map as Map import qualified Data.Set as Set import qualified Data.Text as T import Data.Text.Encoding (decodeUtf8) import Data.Text.Metrics import Lens.Micro (to) import Network.HTTP.Download import Path import Path.Extra (toFilePathNoTrailingSep) import Path.IO import Stack.PackageIndex import Stack.Types.BuildPlan import Stack.Types.PackageIdentifier import Stack.Types.PackageIndex import Stack.Types.PackageName import Stack.Types.Version import qualified System.FilePath as FP import System.IO (SeekMode (AbsoluteSeek)) import System.PosixCompat (setFileMode) data FetchException = Couldn'tReadIndexTarball FilePath Tar.FormatError | Couldn'tReadPackageTarball FilePath SomeException | UnpackDirectoryAlreadyExists (Set FilePath) | CouldNotParsePackageSelectors [String] | UnknownPackageNames (Set PackageName) | UnknownPackageIdentifiers (HashSet PackageIdentifierRevision) String Bool -- Do we use any 00-index.tar.gz indices? Just used for more informative error messages deriving Typeable instance Exception FetchException instance Show FetchException where show (Couldn'tReadIndexTarball fp err) = concat [ "There was an error reading the index tarball " , fp , ": " , show err ] show (Couldn'tReadPackageTarball fp err) = concat [ "There was an error reading the package tarball " , fp , ": " , show err ] show (UnpackDirectoryAlreadyExists dirs) = unlines $ "Unable to unpack due to already present directories:" : map (" " ++) (Set.toList dirs) show (CouldNotParsePackageSelectors strs) = "The following package selectors are not valid package names or identifiers: " ++ intercalate ", " strs show (UnknownPackageNames names) = "The following packages were not found in your indices: " ++ intercalate ", " (map packageNameString $ Set.toList names) show (UnknownPackageIdentifiers idents suggestions uses00Index) = "The following package identifiers were not found in your indices: " ++ intercalate ", " (map packageIdentifierRevisionString $ HashSet.toList idents) ++ (if null suggestions then "" else "\n" ++ suggestions) ++ (if uses00Index then "\n\nYou seem to be using a legacy 00-index.tar.gz tarball.\nConsider changing your configuration to use a 01-index.tar.gz file.\nAlternatively, you can set the ignore-revision-mismatch setting to true.\nFor more information, see: https://github.com/commercialhaskell/stack/issues/3520" else "") -- | Fetch packages into the cache without unpacking fetchPackages :: HasCabalLoader env => Set PackageIdentifier -> RIO env () fetchPackages idents' = do resolved <- resolvePackages Nothing idents Set.empty ToFetchResult toFetch alreadyUnpacked <- getToFetch Nothing resolved assert (Map.null alreadyUnpacked) (return ()) nowUnpacked <- fetchPackages' Nothing toFetch assert (Map.null nowUnpacked) (return ()) where -- Since we're just fetching tarballs and not unpacking cabal files, we can -- always provide a CFILatest cabal file info idents = map (flip PackageIdentifierRevision CFILatest) $ Set.toList idents' -- | Intended to work for the command line command. unpackPackages :: HasCabalLoader env => Maybe SnapshotDef -- ^ when looking up by name, take from this build plan -> FilePath -- ^ destination -> [String] -- ^ names or identifiers -> RIO env () unpackPackages mSnapshotDef dest input = do dest' <- resolveDir' dest (names, idents) <- case partitionEithers $ map parse input of ([], x) -> return $ partitionEithers x (errs, _) -> throwM $ CouldNotParsePackageSelectors errs resolved <- resolvePackages mSnapshotDef idents (Set.fromList names) ToFetchResult toFetch alreadyUnpacked <- getToFetch (Just dest') resolved unless (Map.null alreadyUnpacked) $ throwM $ UnpackDirectoryAlreadyExists $ Set.fromList $ map toFilePath $ Map.elems alreadyUnpacked unpacked <- fetchPackages' Nothing toFetch F.forM_ (Map.toList unpacked) $ \(ident, dest'') -> logInfo $ "Unpacked " <> fromString (packageIdentifierString ident) <> " to " <> fromString (toFilePath dest'') where -- Possible future enhancement: parse names as name + version range parse s = case parsePackageName t of Right x -> Right $ Left x Left _ -> case parsePackageIdentifierRevision t of Right x -> Right $ Right x Left _ -> Left s where t = T.pack s -- | Same as 'unpackPackageIdents', but for a single package. unpackPackageIdent :: HasCabalLoader env => Path Abs Dir -- ^ unpack directory -> Path Rel Dir -- ^ the dist rename directory, see: https://github.com/fpco/stack/issues/157 -> PackageIdentifierRevision -> RIO env (Path Abs Dir) unpackPackageIdent unpackDir distDir (PackageIdentifierRevision ident mcfi) = do -- FIXME make this more direct in the future m <- unpackPackageIdents unpackDir (Just distDir) [PackageIdentifierRevision ident mcfi] case Map.toList m of [(ident', dir)] | ident /= ident' -> error "unpackPackageIdent: ident mismatch" | otherwise -> return dir [] -> error "unpackPackageIdent: empty list" _ -> error "unpackPackageIdent: multiple results" -- | Ensure that all of the given package idents are unpacked into the build -- unpack directory, and return the paths to all of the subdirectories. unpackPackageIdents :: HasCabalLoader env => Path Abs Dir -- ^ unpack directory -> Maybe (Path Rel Dir) -- ^ the dist rename directory, see: https://github.com/fpco/stack/issues/157 -> [PackageIdentifierRevision] -> RIO env (Map PackageIdentifier (Path Abs Dir)) unpackPackageIdents unpackDir mdistDir idents = do resolved <- resolvePackages Nothing idents Set.empty ToFetchResult toFetch alreadyUnpacked <- getToFetch (Just unpackDir) resolved nowUnpacked <- fetchPackages' mdistDir toFetch return $ alreadyUnpacked <> nowUnpacked data ResolvedPackage = ResolvedPackage { rpIdent :: !PackageIdentifier , rpDownload :: !(Maybe PackageDownload) , rpOffsetSize :: !OffsetSize , rpIndex :: !PackageIndex } deriving Show -- | Resolve a set of package names and identifiers into @FetchPackage@ values. resolvePackages :: HasCabalLoader env => Maybe SnapshotDef -- ^ when looking up by name, take from this build plan -> [PackageIdentifierRevision] -> Set PackageName -> RIO env [ResolvedPackage] resolvePackages mSnapshotDef idents0 names0 = do eres <- go case eres of Left _ -> do updateAllIndices go >>= either throwM return Right x -> return x where go = r <$> getUses00Index <*> resolvePackagesAllowMissing mSnapshotDef idents0 names0 r uses00Index (missingNames, missingIdents, idents) | not $ Set.null missingNames = Left $ UnknownPackageNames missingNames | not $ HashSet.null missingIdents = Left $ UnknownPackageIdentifiers missingIdents "" uses00Index | otherwise = Right idents -- | Does the configuration use a 00-index.tar.gz file for indices? -- See getUses00Index :: HasCabalLoader env => RIO env Bool getUses00Index = any is00 <$> view (cabalLoaderL.to clIndices) where is00 :: PackageIndex -> Bool is00 index = "00-index.tar.gz" `T.isInfixOf` indexLocation index -- | Turn package identifiers and package names into a list of -- @ResolvedPackage@s. Returns any unresolved names and -- identifier. These are considered unresolved even if the only -- mismatch is in the cabal file info (MSS 2017-07-17: old versions of -- this code had special handling to treat missing cabal file info as -- a warning, that's no longer necessary or desirable since all info -- should be present and checked). resolvePackagesAllowMissing :: forall env. HasCabalLoader env => Maybe SnapshotDef -- ^ when looking up by name, take from this build plan -> [PackageIdentifierRevision] -> Set PackageName -> RIO env (Set PackageName, HashSet PackageIdentifierRevision, [ResolvedPackage]) resolvePackagesAllowMissing mSnapshotDef idents0 names0 = do cache@(PackageCache cache') <- getPackageCaches -- Find out the latest versions of all packages in the cache let versions = fmap (maximum . HashMap.keys) cache' -- Determines the identifier for a given name, either from -- snapshot information or by taking the latest version -- available getNamed :: PackageName -> Maybe PackageIdentifierRevision getNamed = case mSnapshotDef of Nothing -> getNamedFromIndex Just sd -> getNamedFromSnapshotDef sd -- Use whatever is specified in the snapshot. TODO this does not -- handle the case where a snapshot defines a package outside of -- the index, we'd need a LoadedSnapshot for that. getNamedFromSnapshotDef sd name = do loop $ sdLocations sd where loop [] = Nothing loop (PLIndex ident@(PackageIdentifierRevision (PackageIdentifier name' _) _):rest) | name == name' = Just ident | otherwise = loop rest loop (_:rest) = loop rest -- Take latest version available, including latest cabal file information getNamedFromIndex name = fmap (\ver -> PackageIdentifierRevision (PackageIdentifier name ver) CFILatest) (HashMap.lookup name versions) (missingNames, idents1) = partitionEithers $ map (\name -> maybe (Left name) Right (getNamed name)) (Set.toList names0) cl <- view cabalLoaderL let (missingIdents, resolved) = partitionEithers $ map (\pir -> maybe (Left pir) Right (lookupResolvedPackage cl pir cache)) $ idents0 <> idents1 return (Set.fromList missingNames, HashSet.fromList missingIdents, resolved) lookupResolvedPackage :: CabalLoader -> PackageIdentifierRevision -> PackageCache PackageIndex -> Maybe ResolvedPackage lookupResolvedPackage cl (PackageIdentifierRevision ident@(PackageIdentifier name version) cfi) (PackageCache cache) = do (index, mdownload, files) <- HashMap.lookup name cache >>= HashMap.lookup version let moffsetSize = case cfi of CFILatest -> Just $ snd $ NE.last files CFIHash _msize hash' -> -- TODO check size? lookup hash' $ concatMap (\(hashes, x) -> map (, x) hashes) $ NE.toList files CFIRevision rev -> fmap snd $ listToMaybe $ drop (fromIntegral rev) $ NE.toList files offsetSize <- case moffsetSize of Just x -> Just x Nothing | clIgnoreRevisionMismatch cl -> Just $ snd $ NE.last files | otherwise -> Nothing Just ResolvedPackage { rpIdent = ident , rpDownload = mdownload , rpOffsetSize = offsetSize , rpIndex = index } data ToFetch = ToFetch { tfTarball :: !(Path Abs File) , tfDestDir :: !(Maybe (Path Abs Dir)) , tfUrl :: !T.Text , tfSize :: !(Maybe Word64) , tfSHA256 :: !(Maybe StaticSHA256) , tfCabal :: !ByteString -- ^ Contents of the .cabal file } data ToFetchResult = ToFetchResult { tfrToFetch :: !(Map PackageIdentifier ToFetch) , tfrAlreadyUnpacked :: !(Map PackageIdentifier (Path Abs Dir)) } -- | Add the cabal files to a list of idents with their caches. withCabalFiles :: HasCabalLoader env => IndexName -> [(ResolvedPackage, a)] -> (PackageIdentifier -> a -> ByteString -> IO b) -> RIO env [b] withCabalFiles name pkgs f = do indexPath <- configPackageIndex name withBinaryFile (toFilePath indexPath) ReadMode $ \h -> mapM (goPkg h) pkgs where goPkg h (ResolvedPackage { rpIdent = ident, rpOffsetSize = OffsetSize offset size }, tf) = do -- Did not find warning for tarballs is handled above liftIO $ do hSeek h AbsoluteSeek $ fromIntegral offset cabalBS <- S.hGet h $ fromIntegral size f ident tf cabalBS loadFromIndex :: HasCabalLoader env => PackageIdentifierRevision -> RIO env ByteString loadFromIndex ident = do -- TODO in the future, keep all of the necessary @Handle@s open bothCaches <- getPackageCaches mres <- lookupPackageIdentifierExact ident bothCaches case mres of Just bs -> return bs -- Update the cache and try again Nothing -> do let fuzzy = fuzzyLookupCandidates ident bothCaches suggestions = case fuzzy of FRNameNotFound Nothing -> "" FRNameNotFound (Just cs) -> "Perhaps you meant " <> orSeparated cs <> "?" FRVersionNotFound cs -> "Possible candidates: " <> commaSeparated (NE.map packageIdentifierText cs) <> "." FRRevisionNotFound cs -> "The specified revision was not found.\nPossible candidates: " <> commaSeparated (NE.map (T.pack . packageIdentifierRevisionString) cs) <> "." cl <- view cabalLoaderL join $ modifyMVar (clUpdateRef cl) $ \toUpdate -> if toUpdate then do logInfo $ "Didn't see " <> fromString (packageIdentifierRevisionString ident) <> " in your package indices.\n" <> "Updating and trying again." updateAllIndices _ <- getPackageCaches return (False, loadFromIndex ident) else do uses00Index <- getUses00Index return (toUpdate, throwIO $ UnknownPackageIdentifiers (HashSet.singleton ident) (T.unpack suggestions) uses00Index) lookupPackageIdentifierExact :: HasCabalLoader env => PackageIdentifierRevision -> PackageCache PackageIndex -> RIO env (Maybe ByteString) lookupPackageIdentifierExact identRev cache = do cl <- view cabalLoaderL case lookupResolvedPackage cl identRev cache of Nothing -> return Nothing Just rp -> do bss <- withCabalFiles (indexName (rpIndex rp)) [(rp, ())] $ \_ _ bs -> return bs case bss of [bs] -> return (Just bs) _ -> return Nothing data FuzzyResults = FRNameNotFound !(Maybe (NonEmpty T.Text)) | FRVersionNotFound !(NonEmpty PackageIdentifier) | FRRevisionNotFound !(NonEmpty PackageIdentifierRevision) -- | Given package identifier and package caches, return list of packages -- with the same name and the same two first version number components found -- in the caches. fuzzyLookupCandidates :: PackageIdentifierRevision -> PackageCache index -> FuzzyResults fuzzyLookupCandidates (PackageIdentifierRevision (PackageIdentifier name ver) _rev) (PackageCache caches) = case HashMap.lookup name caches of Nothing -> FRNameNotFound $ typoCorrectionCandidates name (PackageCache caches) Just m -> case HashMap.lookup ver m of Nothing -> case NE.nonEmpty $ filter sameMajor $ HashMap.keys m of Just vers -> FRVersionNotFound $ NE.map (PackageIdentifier name) vers Nothing -> case NE.nonEmpty $ HashMap.keys m of Nothing -> error "fuzzyLookupCandidates: no versions" Just vers -> FRVersionNotFound $ NE.map (PackageIdentifier name) vers Just (_index, _mpd, revisions) -> let hashes = concatMap fst $ NE.toList revisions pirs = map (PackageIdentifierRevision (PackageIdentifier name ver) . CFIHash Nothing) hashes in case NE.nonEmpty pirs of Nothing -> error "fuzzyLookupCandidates: no revisions" Just pirs' -> FRRevisionNotFound pirs' where sameMajor v = toMajorVersion v == toMajorVersion ver -- | Try to come up with typo corrections for given package identifier using -- package caches. This should be called before giving up, i.e. when -- 'fuzzyLookupCandidates' cannot return anything. typoCorrectionCandidates :: PackageName -> PackageCache index -> Maybe (NonEmpty T.Text) typoCorrectionCandidates name' (PackageCache cache) = let name = packageNameText name' in NE.nonEmpty . take 10 . map snd . filter (\(distance, _) -> distance < 4) . map (\k -> (damerauLevenshtein name (packageNameText k), packageNameText k)) . HashMap.keys $ cache -- | Figure out where to fetch from. getToFetch :: HasCabalLoader env => Maybe (Path Abs Dir) -- ^ directory to unpack into, @Nothing@ means no unpack -> [ResolvedPackage] -> RIO env ToFetchResult getToFetch mdest resolvedAll = do (toFetch0, unpacked) <- liftM partitionEithers $ mapM checkUnpacked resolvedAll toFetch1 <- mapM goIndex $ Map.toList $ Map.fromListWith (++) toFetch0 return ToFetchResult { tfrToFetch = Map.unions toFetch1 , tfrAlreadyUnpacked = Map.fromList unpacked } where checkUnpacked resolved = do let ident = rpIdent resolved dirRel <- parseRelDir $ packageIdentifierString ident let mdestDir = ( dirRel) <$> mdest mexists <- case mdestDir of Nothing -> return Nothing Just destDir -> do exists <- doesDirExist destDir return $ if exists then Just destDir else Nothing case mexists of Just destDir -> return $ Right (ident, destDir) Nothing -> do let index = rpIndex resolved d = rpDownload resolved targz = T.pack $ packageIdentifierString ident ++ ".tar.gz" tarball <- configPackageTarball (indexName index) ident return $ Left (indexName index, [(resolved, ToFetch { tfTarball = tarball , tfDestDir = mdestDir , tfUrl = case fmap pdUrl d of Just url | not (S.null url) -> decodeUtf8 url _ -> indexDownloadPrefix index <> targz , tfSize = fmap pdSize d , tfSHA256 = fmap pdSHA256 d , tfCabal = S.empty -- filled in by goIndex })]) goIndex (name, pkgs) = liftM Map.fromList $ withCabalFiles name pkgs $ \ident tf cabalBS -> return (ident, tf { tfCabal = cabalBS }) -- | Download the given name,version pairs into the directory expected by cabal. -- -- For each package it downloads, it will optionally unpack it to the given -- @Path@ (if present). Note that unpacking is not simply a matter of -- untarring, but also of grabbing the cabal file from the package index. The -- destinations should not include package identifiers. -- -- Returns the list of paths unpacked, including package identifiers. E.g.: -- -- @ -- fetchPackages [("foo-1.2.3", Just "/some/dest")] ==> ["/some/dest/foo-1.2.3"] -- @ -- -- Since 0.1.0.0 fetchPackages' :: forall env. HasCabalLoader env => Maybe (Path Rel Dir) -- ^ the dist rename directory, see: https://github.com/fpco/stack/issues/157 -> Map PackageIdentifier ToFetch -> RIO env (Map PackageIdentifier (Path Abs Dir)) fetchPackages' mdistDir toFetchAll = do connCount <- view $ cabalLoaderL.to clConnectionCount outputVar <- newTVarIO Map.empty parMapM_ connCount (go outputVar) (Map.toList toFetchAll) readTVarIO outputVar where go :: TVar (Map PackageIdentifier (Path Abs Dir)) -> (PackageIdentifier, ToFetch) -> RIO env () go outputVar (ident, toFetch) = do req <- parseUrlThrow $ T.unpack $ tfUrl toFetch let destpath = tfTarball toFetch let toHashCheck bs = HashCheck SHA256 (CheckHexDigestByteString bs) let downloadReq = DownloadRequest { drRequest = req , drHashChecks = map (toHashCheck . staticSHA256ToBase16) $ maybeToList (tfSHA256 toFetch) , drLengthCheck = fromIntegral <$> tfSize toFetch , drRetryPolicy = drRetryPolicyDefault } let progressSink _ = logInfo $ display ident <> ": download" _ <- verifiedDownload downloadReq destpath progressSink identStrP <- parseRelDir $ packageIdentifierString ident F.forM_ (tfDestDir toFetch) $ \destDir -> do let innerDest = toFilePath destDir unexpectedEntries <- liftIO $ untar destpath identStrP (parent destDir) liftIO $ do case mdistDir of Nothing -> return () -- See: https://github.com/fpco/stack/issues/157 Just distDir -> do let inner = parent destDir identStrP oldDist = inner $(mkRelDir "dist") newDist = inner distDir exists <- doesDirExist oldDist when exists $ do -- Previously used takeDirectory, but that got confused -- by trailing slashes, see: -- https://github.com/commercialhaskell/stack/issues/216 -- -- Instead, use Path which is a bit more resilient ensureDir $ parent newDist renameDir oldDist newDist let cabalFP = innerDest FP. packageNameString (packageIdentifierName ident) FP.<.> "cabal" S.writeFile cabalFP $ tfCabal toFetch atomically $ modifyTVar outputVar $ Map.insert ident destDir F.forM_ unexpectedEntries $ \(path, entryType) -> logWarn $ "Unexpected entry type " <> display entryType <> " for entry " <> fromString path -- | Internal function used to unpack tarball. -- -- Takes a path to a .tar.gz file, the name of the directory it should contain, -- and a destination folder to extract the tarball into. Returns unexpected -- entries, as pairs of paths and descriptions. untar :: forall b1 b2. Path b1 File -> Path Rel Dir -> Path b2 Dir -> IO [(FilePath, T.Text)] untar tarPath expectedTarFolder destDirParent = do ensureDir destDirParent withLazyFile (toFilePath tarPath) $ \lbs -> do let rawEntries = fmap (either wrap wrap) $ Tar.checkTarbomb (toFilePathNoTrailingSep expectedTarFolder) $ Tar.read $ decompress lbs filterEntries :: (Semigroup w, Monoid w) => (Tar.Entry -> (Bool, w)) -> Tar.Entries b -> (Tar.Entries b, w) -- Allow collecting warnings, Writer-monad style. filterEntries f = Tar.foldEntries (\e -> let (res, w) = f e in \(rest, wOld) -> ((if res then Tar.Next e else id) rest, wOld <> w)) (Tar.Done, mempty) (\err -> (Tar.Fail err, mempty)) extractableEntry e = case Tar.entryContent e of Tar.NormalFile _ _ -> (True, []) Tar.Directory -> (True, []) Tar.SymbolicLink _ -> (True, []) Tar.HardLink _ -> (True, []) Tar.OtherEntryType 'g' _ _ -> (False, []) Tar.OtherEntryType 'x' _ _ -> (False, []) Tar.CharacterDevice _ _ -> (False, [(path, "character device")]) Tar.BlockDevice _ _ -> (False, [(path, "block device")]) Tar.NamedPipe -> (False, [(path, "named pipe")]) Tar.OtherEntryType code _ _ -> (False, [(path, "other entry type with code " <> T.pack (show code))]) where path = Tar.fromTarPath $ Tar.entryTarPath e (entries, unexpectedEntries) = filterEntries extractableEntry rawEntries wrap :: Exception e => e -> FetchException wrap = Couldn'tReadPackageTarball (toFilePath tarPath) . toException getPerms :: Tar.Entry -> (FilePath, Tar.Permissions) getPerms e = (toFilePath destDirParent FP. Tar.fromTarPath (Tar.entryTarPath e), Tar.entryPermissions e) filePerms :: [(FilePath, Tar.Permissions)] filePerms = catMaybes $ Tar.foldEntries (\e -> (:) (Just $ getPerms e)) [] (const []) entries Tar.unpack (toFilePath destDirParent) entries -- Reset file permissions as they were in the tarball, but only -- for extracted entries (whence filterEntries extractableEntry above). -- See https://github.com/commercialhaskell/stack/issues/2361 mapM_ (\(fp, perm) -> setFileMode (FP.dropTrailingPathSeparator fp) perm) filePerms return unexpectedEntries parMapM_ :: (F.Foldable f,MonadUnliftIO m) => Int -> (a -> m ()) -> f a -> m () parMapM_ (max 1 -> 1) f xs = F.mapM_ f xs parMapM_ cnt f xs0 = withRunInIO $ \run -> do var <- newTVarIO $ F.toList xs0 replicateConcurrently_ cnt $ fix $ \loop -> join $ atomically $ do xs <- readTVar var case xs of [] -> return $ return () x:xs' -> do writeTVar var xs' return $ do run $ f x loop orSeparated :: NonEmpty T.Text -> T.Text orSeparated xs | NE.length xs == 1 = NE.head xs | NE.length xs == 2 = NE.head xs <> " or " <> NE.last xs | otherwise = T.intercalate ", " (NE.init xs) <> ", or " <> NE.last xs commaSeparated :: NonEmpty T.Text -> T.Text commaSeparated = F.fold . NE.intersperse ", " -- | Location of a package tarball configPackageTarball :: HasCabalLoader env => IndexName -> PackageIdentifier -> RIO env (Path Abs File) configPackageTarball iname ident = do root <- configPackageIndexRoot iname name <- parseRelDir $ packageNameString $ packageIdentifierName ident ver <- parseRelDir $ versionString $ packageIdentifierVersion ident base <- parseRelFile $ packageIdentifierString ident ++ ".tar.gz" return (root $(mkRelDir "packages") name ver base) stack-1.9.3.1/src/Stack/FileWatch.hs0000644000000000000000000001172213455617610015227 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude #-} {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TupleSections #-} module Stack.FileWatch ( fileWatch , fileWatchPoll ) where import Control.Concurrent.STM (check) import Stack.Prelude import qualified Data.Map.Strict as Map import qualified Data.Set as Set import GHC.IO.Exception import Path import System.FSNotify import System.IO (hPutStrLn, getLine) fileWatch :: Handle -> ((Set (Path Abs File) -> IO ()) -> IO ()) -> IO () fileWatch = fileWatchConf defaultConfig fileWatchPoll :: Handle -> ((Set (Path Abs File) -> IO ()) -> IO ()) -> IO () fileWatchPoll = fileWatchConf $ defaultConfig { confUsePolling = True } -- | Run an action, watching for file changes -- -- The action provided takes a callback that is used to set the files to be -- watched. When any of those files are changed, we rerun the action again. fileWatchConf :: WatchConfig -> Handle -> ((Set (Path Abs File) -> IO ()) -> IO ()) -> IO () fileWatchConf cfg out inner = withManagerConf cfg $ \manager -> do let putLn = hPutStrLn out outputIsTerminal <- hIsTerminalDeviceOrMinTTY out let withColor color str = putLn $ do if outputIsTerminal then concat [color, str, reset] else str allFiles <- newTVarIO Set.empty dirtyVar <- newTVarIO True watchVar <- newTVarIO Map.empty let onChange event = atomically $ do files <- readTVar allFiles when (eventPath event `Set.member` files) (writeTVar dirtyVar True) setWatched :: Set (Path Abs File) -> IO () setWatched files = do atomically $ writeTVar allFiles $ Set.map toFilePath files watch0 <- readTVarIO watchVar let actions = Map.mergeWithKey keepListening stopListening startListening watch0 newDirs watch1 <- forM (Map.toList actions) $ \(k, mmv) -> do mv <- mmv return $ case mv of Nothing -> Map.empty Just v -> Map.singleton k v atomically $ writeTVar watchVar $ Map.unions watch1 where newDirs = Map.fromList $ map (, ()) $ Set.toList $ Set.map parent files keepListening _dir listen () = Just $ return $ Just listen stopListening = Map.map $ \f -> do () <- f `catch` \ioe -> -- Ignore invalid argument error - it can happen if -- the directory is removed. case ioe_type ioe of InvalidArgument -> return () _ -> throwIO ioe return Nothing startListening = Map.mapWithKey $ \dir () -> do let dir' = fromString $ toFilePath dir listen <- watchDir manager dir' (const True) onChange return $ Just listen let watchInput = do line <- getLine unless (line == "quit") $ do case line of "help" -> do putLn "" putLn "help: display this help" putLn "quit: exit" putLn "build: force a rebuild" putLn "watched: display watched files" "build" -> atomically $ writeTVar dirtyVar True "watched" -> do watch <- readTVarIO allFiles mapM_ putLn (Set.toList watch) "" -> atomically $ writeTVar dirtyVar True _ -> putLn $ concat [ "Unknown command: " , show line , ". Try 'help'" ] watchInput race_ watchInput $ forever $ do atomically $ do dirty <- readTVar dirtyVar check dirty eres <- tryAny $ inner setWatched -- Clear dirtiness flag after the build to avoid an infinite -- loop caused by the build itself triggering dirtiness. This -- could be viewed as a bug, since files changed during the -- build will not trigger an extra rebuild, but overall seems -- like better behavior. See -- https://github.com/commercialhaskell/stack/issues/822 atomically $ writeTVar dirtyVar False case eres of Left e -> do let color = case fromException e of Just ExitSuccess -> green _ -> red withColor color $ show e _ -> withColor green "Success! Waiting for next file change." putLn "Type help for available commands. Press enter to force a rebuild." green, red, reset :: String green = "\ESC[32m" red = "\ESC[31m" reset = "\ESC[0m" stack-1.9.3.1/src/Stack/GhcPkg.hs0000644000000000000000000001571613455617610014533 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude #-} {-# LANGUAGE DataKinds #-} {-# LANGUAGE FlexibleContexts #-} {-# LANGUAGE BangPatterns #-} {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE DeriveDataTypeable #-} {-# LANGUAGE TemplateHaskell #-} {-# LANGUAGE TupleSections #-} {-# OPTIONS -fno-warn-unused-do-bind #-} -- | Functions for the GHC package database. module Stack.GhcPkg (getGlobalDB ,findGhcPkgField ,createDatabase ,unregisterGhcPkgId ,getCabalPkgVer ,ghcPkgExeName ,ghcPkgPathEnvVar ,mkGhcPackagePath) where import Stack.Prelude import qualified Data.ByteString.Char8 as S8 import qualified Data.ByteString.Lazy as BL import Data.List import qualified Data.Text as T import qualified Data.Text.Encoding as T import Path (parent, mkRelFile, ()) import Path.Extra (toFilePathNoTrailingSep) import Path.IO import Stack.Constants import Stack.Types.Build import Stack.Types.GhcPkgId import Stack.Types.PackageIdentifier import Stack.Types.Compiler import Stack.Types.PackageName import Stack.Types.Version import System.FilePath (searchPathSeparator) import RIO.Process -- | Get the global package database getGlobalDB :: (HasProcessContext env, HasLogFunc env) => WhichCompiler -> RIO env (Path Abs Dir) getGlobalDB wc = do logDebug "Getting global package database location" -- This seems like a strange way to get the global package database -- location, but I don't know of a better one bs <- ghcPkg wc [] ["list", "--global"] >>= either throwIO return let fp = S8.unpack $ stripTrailingColon $ firstLine bs liftIO $ resolveDir' fp where stripTrailingColon bs | S8.null bs = bs | S8.last bs == ':' = S8.init bs | otherwise = bs firstLine = S8.takeWhile (\c -> c /= '\r' && c /= '\n') -- | Run the ghc-pkg executable ghcPkg :: (HasProcessContext env, HasLogFunc env) => WhichCompiler -> [Path Abs Dir] -> [String] -> RIO env (Either SomeException S8.ByteString) ghcPkg wc pkgDbs args = do eres <- go case eres of Left _ -> do mapM_ (createDatabase wc) pkgDbs go Right _ -> return eres where go = tryAny $ BL.toStrict . fst <$> proc (ghcPkgExeName wc) args' readProcess_ args' = packageDbFlags pkgDbs ++ args -- | Create a package database in the given directory, if it doesn't exist. createDatabase :: (HasProcessContext env, HasLogFunc env) => WhichCompiler -> Path Abs Dir -> RIO env () createDatabase wc db = do exists <- doesFileExist (db $(mkRelFile "package.cache")) unless exists $ do -- ghc-pkg requires that the database directory does not exist -- yet. If the directory exists but the package.cache file -- does, we're in a corrupted state. Check for that state. dirExists <- doesDirExist db args <- if dirExists then do logWarn $ "The package database located at " <> fromString (toFilePath db) <> " is corrupted (missing its package.cache file)." logWarn "Proceeding with a recache" return ["--package-db", toFilePath db, "recache"] else do -- Creating the parent doesn't seem necessary, as ghc-pkg -- seems to be sufficiently smart. But I don't feel like -- finding out it isn't the hard way ensureDir (parent db) return ["init", toFilePath db] void $ proc (ghcPkgExeName wc) args $ \pc -> readProcess_ pc `onException` logError ("Unable to create package database at " <> fromString (toFilePath db)) -- | Get the name to use for "ghc-pkg", given the compiler version. ghcPkgExeName :: WhichCompiler -> String ghcPkgExeName Ghc = "ghc-pkg" ghcPkgExeName Ghcjs = "ghcjs-pkg" -- | Get the environment variable to use for the package DB paths. ghcPkgPathEnvVar :: WhichCompiler -> Text ghcPkgPathEnvVar Ghc = "GHC_PACKAGE_PATH" ghcPkgPathEnvVar Ghcjs = "GHCJS_PACKAGE_PATH" -- | Get the necessary ghc-pkg flags for setting up the given package database packageDbFlags :: [Path Abs Dir] -> [String] packageDbFlags pkgDbs = "--no-user-package-db" : map (\x -> "--package-db=" ++ toFilePath x) pkgDbs -- | Get the value of a field of the package. findGhcPkgField :: (HasProcessContext env, HasLogFunc env) => WhichCompiler -> [Path Abs Dir] -- ^ package databases -> String -- ^ package identifier, or GhcPkgId -> Text -> RIO env (Maybe Text) findGhcPkgField wc pkgDbs name field = do result <- ghcPkg wc pkgDbs ["field", "--simple-output", name, T.unpack field] return $ case result of Left{} -> Nothing Right bs -> fmap (stripCR . T.decodeUtf8) $ listToMaybe $ S8.lines bs -- | Get the version of the package findGhcPkgVersion :: (HasProcessContext env, HasLogFunc env) => WhichCompiler -> [Path Abs Dir] -- ^ package databases -> PackageName -> RIO env (Maybe Version) findGhcPkgVersion wc pkgDbs name = do mv <- findGhcPkgField wc pkgDbs (packageNameString name) "version" case mv of Just !v -> return (parseVersion v) _ -> return Nothing unregisterGhcPkgId :: (HasProcessContext env, HasLogFunc env) => WhichCompiler -> CompilerVersion 'CVActual -> Path Abs Dir -- ^ package database -> GhcPkgId -> PackageIdentifier -> RIO env () unregisterGhcPkgId wc cv pkgDb gid ident = do eres <- ghcPkg wc [pkgDb] args case eres of Left e -> logWarn $ displayShow e Right _ -> return () where -- TODO ideally we'd tell ghc-pkg a GhcPkgId instead args = "unregister" : "--user" : "--force" : (case cv of GhcVersion v | v < $(mkVersion "7.9") -> [packageIdentifierString ident] _ -> ["--ipid", ghcPkgIdString gid]) -- | Get the version of Cabal from the global package database. getCabalPkgVer :: (HasProcessContext env, HasLogFunc env) => WhichCompiler -> RIO env Version getCabalPkgVer wc = do logDebug "Getting Cabal package version" mres <- findGhcPkgVersion wc [] -- global DB cabalPackageName maybe (throwIO $ Couldn'tFindPkgId cabalPackageName) return mres -- | Get the value for GHC_PACKAGE_PATH mkGhcPackagePath :: Bool -> Path Abs Dir -> Path Abs Dir -> [Path Abs Dir] -> Path Abs Dir -> Text mkGhcPackagePath locals localdb deps extras globaldb = T.pack $ intercalate [searchPathSeparator] $ concat [ [toFilePathNoTrailingSep localdb | locals] , [toFilePathNoTrailingSep deps] , [toFilePathNoTrailingSep db | db <- reverse extras] , [toFilePathNoTrailingSep globaldb] ] stack-1.9.3.1/src/Stack/Ghci.hs0000644000000000000000000012215113455617610014232 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude #-} {-# LANGUAGE FlexibleContexts #-} {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TemplateHaskell #-} {-# LANGUAGE TupleSections #-} {-# LANGUAGE DeriveDataTypeable #-} {-# LANGUAGE RecordWildCards #-} {-# LANGUAGE CPP #-} {-# LANGUAGE ConstraintKinds #-} -- | Run a GHCi configured with the user's package(s). module Stack.Ghci ( GhciOpts(..) , GhciPkgInfo(..) , GhciException(..) , ghci ) where import Stack.Prelude hiding (Display (..)) import Control.Monad.State.Strict (State, execState, get, modify) import qualified Data.ByteString.Char8 as S8 import qualified Data.ByteString.Lazy as LBS import Data.List import qualified Data.Map.Strict as M import qualified Data.Set as S import qualified Data.Text as T import qualified Data.Text.Lazy as TL import qualified Data.Text.Lazy.Encoding as TLE import qualified Distribution.PackageDescription as C import Path import Path.Extra (toFilePathNoTrailingSep) import Path.IO hiding (withSystemTempDir) import qualified RIO import RIO.Process (HasProcessContext, exec, proc, readProcess_) import Stack.Build import Stack.Build.Installed import Stack.Build.Source import Stack.Build.Target import Stack.Config (getLocalPackages) import Stack.Constants.Config import Stack.Ghci.Script import Stack.Package import Stack.PrettyPrint import Stack.Types.Build import Stack.Types.Compiler import Stack.Types.Config import Stack.Types.FlagName import Stack.Types.NamedComponent import Stack.Types.Package import Stack.Types.PackageIdentifier import Stack.Types.PackageName import Stack.Types.Runner import System.IO (putStrLn) import System.IO.Temp (getCanonicalTemporaryDirectory) #ifndef WINDOWS import qualified System.Posix.Files as Posix #endif -- | Command-line options for GHC. data GhciOpts = GhciOpts { ghciTargets :: ![Text] , ghciArgs :: ![String] , ghciGhcOptions :: ![Text] , ghciFlags :: !(Map (Maybe PackageName) (Map FlagName Bool)) , ghciGhcCommand :: !(Maybe FilePath) , ghciNoLoadModules :: !Bool , ghciAdditionalPackages :: ![String] , ghciMainIs :: !(Maybe Text) , ghciLoadLocalDeps :: !Bool , ghciSkipIntermediate :: !Bool , ghciHidePackages :: !(Maybe Bool) , ghciNoBuild :: !Bool , ghciOnlyMain :: !Bool } deriving Show -- | Necessary information to load a package or its components. data GhciPkgInfo = GhciPkgInfo { ghciPkgName :: !PackageName , ghciPkgOpts :: ![(NamedComponent, BuildInfoOpts)] , ghciPkgDir :: !(Path Abs Dir) , ghciPkgModules :: !ModuleMap , ghciPkgCFiles :: !(Set (Path Abs File)) -- ^ C files. , ghciPkgMainIs :: !(Map NamedComponent (Set (Path Abs File))) , ghciPkgTargetFiles :: !(Maybe (Set (Path Abs File))) , ghciPkgPackage :: !Package } deriving Show -- | Loaded package description and related info. data GhciPkgDesc = GhciPkgDesc { ghciDescPkg :: !Package , ghciDescCabalFp :: !(Path Abs File) , ghciDescTarget :: !Target } -- Mapping from a module name to a map with all of the paths that use -- that name. Each of those paths is associated with a set of components -- that contain it. Purpose of this complex structure is for use in -- 'checkForDuplicateModules'. type ModuleMap = Map ModuleName (Map (Path Abs File) (Set (PackageName, NamedComponent))) unionModuleMaps :: [ModuleMap] -> ModuleMap unionModuleMaps = M.unionsWith (M.unionWith S.union) data GhciException = InvalidPackageOption String | LoadingDuplicateModules | MissingFileTarget String | Can'tSpecifyFilesAndTargets | Can'tSpecifyFilesAndMainIs | GhciTargetParseException [Text] deriving (Typeable) instance Exception GhciException instance Show GhciException where show (InvalidPackageOption name) = "Failed to parse --package option " ++ name show LoadingDuplicateModules = unlines [ "Not attempting to start ghci due to these duplicate modules." , "Use --no-load to try to start it anyway, without loading any modules (but these are still likely to cause errors)" ] show (MissingFileTarget name) = "Cannot find file target " ++ name show Can'tSpecifyFilesAndTargets = "Cannot use 'stack ghci' with both file targets and package targets" show Can'tSpecifyFilesAndMainIs = "Cannot use 'stack ghci' with both file targets and --main-is flag" show (GhciTargetParseException xs) = show (TargetParseException xs) ++ "\nNote that to specify options to be passed to GHCi, use the --ghci-options flag" -- | Launch a GHCi session for the given local package targets with the -- given options and configure it with the load paths and extensions -- of those targets. ghci :: HasEnvConfig env => GhciOpts -> RIO env () ghci opts@GhciOpts{..} = do let buildOptsCLI = defaultBuildOptsCLI { boptsCLITargets = [] , boptsCLIFlags = ghciFlags } -- Load source map, without explicit targets, to collect all info. (locals, sourceMap) <- loadSourceMap AllowNoTargets buildOptsCLI -- Parse --main-is argument. mainIsTargets <- parseMainIsTargets buildOptsCLI ghciMainIs -- Parse to either file targets or build targets etargets <- preprocessTargets buildOptsCLI ghciTargets (inputTargets, mfileTargets) <- case etargets of Right packageTargets -> return (packageTargets, Nothing) Left rawFileTargets -> do case mainIsTargets of Nothing -> return () Just _ -> throwM Can'tSpecifyFilesAndMainIs -- Figure out targets based on filepath targets (targetMap, fileInfo, extraFiles) <- findFileTargets locals rawFileTargets return (targetMap, Just (fileInfo, extraFiles)) -- Get a list of all the local target packages. localTargets <- getAllLocalTargets opts inputTargets mainIsTargets sourceMap -- Get a list of all the non-local target packages. nonLocalTargets <- getAllNonLocalTargets inputTargets -- Check if additional package arguments are sensible. addPkgs <- checkAdditionalPackages ghciAdditionalPackages -- Load package descriptions. pkgDescs <- loadGhciPkgDescs buildOptsCLI localTargets -- If necessary, ask user about which main module to load. bopts <- view buildOptsL mainFile <- if ghciNoLoadModules then return Nothing else do -- Figure out package files, in order to ask the user -- about which main module to load. See the note below for -- why this is done again after the build. This could -- potentially be done more efficiently, because all we -- need is the location of main modules, not the rest. pkgs0 <- getGhciPkgInfos sourceMap addPkgs (fmap fst mfileTargets) pkgDescs figureOutMainFile bopts mainIsTargets localTargets pkgs0 -- Build required dependencies and setup local packages. stackYaml <- view stackYamlL buildDepsAndInitialSteps opts (map (packageNameText . fst) localTargets) targetWarnings stackYaml localTargets nonLocalTargets mfileTargets -- Load the list of modules _after_ building, to catch changes in -- unlisted dependencies (#1180) pkgs <- getGhciPkgInfos sourceMap addPkgs (fmap fst mfileTargets) pkgDescs checkForIssues pkgs -- Finally, do the invocation of ghci runGhci opts localTargets mainFile pkgs (maybe [] snd mfileTargets) (nonLocalTargets ++ addPkgs) preprocessTargets :: HasEnvConfig env => BuildOptsCLI -> [Text] -> RIO env (Either [Path Abs File] (Map PackageName Target)) preprocessTargets buildOptsCLI rawTargets = do let (fileTargetsRaw, normalTargetsRaw) = partition (\t -> ".hs" `T.isSuffixOf` t || ".lhs" `T.isSuffixOf` t) rawTargets -- Only use file targets if we have no normal targets. if not (null fileTargetsRaw) && null normalTargetsRaw then do fileTargets <- forM fileTargetsRaw $ \fp0 -> do let fp = T.unpack fp0 mpath <- liftIO $ forgivingAbsence (resolveFile' fp) case mpath of Nothing -> throwM (MissingFileTarget fp) Just path -> return path return (Left fileTargets) else do -- Try parsing targets before checking if both file and -- module targets are specified (see issue#3342). (_,_,normalTargets) <- parseTargets AllowNoTargets buildOptsCLI { boptsCLITargets = normalTargetsRaw } `catch` \ex -> case ex of TargetParseException xs -> throwM (GhciTargetParseException xs) _ -> throwM ex unless (null fileTargetsRaw) $ throwM Can'tSpecifyFilesAndTargets return (Right normalTargets) parseMainIsTargets :: HasEnvConfig env => BuildOptsCLI -> Maybe Text -> RIO env (Maybe (Map PackageName Target)) parseMainIsTargets buildOptsCLI mtarget = forM mtarget $ \target -> do (_,_,targets) <- parseTargets AllowNoTargets buildOptsCLI { boptsCLITargets = [target] } return targets findFileTargets :: HasEnvConfig env => [LocalPackage] -> [Path Abs File] -> RIO env (Map PackageName Target, Map PackageName (Set (Path Abs File)), [Path Abs File]) findFileTargets locals fileTargets = do filePackages <- forM locals $ \lp -> do (_,compFiles,_,_) <- getPackageFiles (packageFiles (lpPackage lp)) (lpCabalFile lp) return (lp, M.map (S.map dotCabalGetPath) compFiles) let foundFileTargetComponents :: [(Path Abs File, [(PackageName, NamedComponent)])] foundFileTargetComponents = map (\fp -> (fp, ) $ sort $ concatMap (\(lp, files) -> map ((packageName (lpPackage lp), ) . fst) (filter (S.member fp . snd) (M.toList files)) ) filePackages ) fileTargets results <- forM foundFileTargetComponents $ \(fp, xs) -> case xs of [] -> do prettyWarn $ vsep [ "Couldn't find a component for file target" <+> display fp <> ". This means that the correct ghc options might not be used." , "Attempting to load the file anyway." ] return $ Left fp [x] -> do prettyInfo $ "Using configuration for" <+> display x <+> "to load" <+> display fp return $ Right (fp, x) (x:_) -> do prettyWarn $ "Multiple components contain file target" <+> display fp <> ":" <+> mconcat (intersperse ", " (map display xs)) <> line <> "Guessing the first one," <+> display x <> "." return $ Right (fp, x) let (extraFiles, associatedFiles) = partitionEithers results targetMap = foldl unionTargets M.empty $ map (\(_, (name, comp)) -> M.singleton name (TargetComps (S.singleton comp))) associatedFiles infoMap = foldl (M.unionWith S.union) M.empty $ map (\(fp, (name, _)) -> M.singleton name (S.singleton fp)) associatedFiles return (targetMap, infoMap, extraFiles) getAllLocalTargets :: HasEnvConfig env => GhciOpts -> Map PackageName Target -> Maybe (Map PackageName Target) -> SourceMap -> RIO env [(PackageName, (Path Abs File, Target))] getAllLocalTargets GhciOpts{..} targets0 mainIsTargets sourceMap = do -- Use the 'mainIsTargets' as normal targets, for CLI concision. See -- #1845. This is a little subtle - we need to do the target parsing -- independently in order to handle the case where no targets are -- specified. let targets = maybe targets0 (unionTargets targets0) mainIsTargets packages <- lpProject <$> getLocalPackages -- Find all of the packages that are directly demanded by the -- targets. directlyWanted <- forMaybeM (M.toList packages) $ \(name, lpv) -> case M.lookup name targets of Just simpleTargets -> return (Just (name, (lpvCabalFP lpv, simpleTargets))) Nothing -> return Nothing -- Figure out let extraLoadDeps = getExtraLoadDeps ghciLoadLocalDeps sourceMap directlyWanted if (ghciSkipIntermediate && not ghciLoadLocalDeps) || null extraLoadDeps then return directlyWanted else do let extraList = mconcat $ intersperse ", " (map (RIO.display . fst) extraLoadDeps) if ghciLoadLocalDeps then logInfo $ "The following libraries will also be loaded into GHCi because " <> "they are local dependencies of your targets, and you specified --load-local-deps:\n " <> extraList else logInfo $ "The following libraries will also be loaded into GHCi because " <> "they are intermediate dependencies of your targets:\n " <> extraList <> "\n(Use --skip-intermediate-deps to omit these)" return (directlyWanted ++ extraLoadDeps) getAllNonLocalTargets :: Map PackageName Target -> RIO env [PackageName] getAllNonLocalTargets targets = do let isNonLocal (TargetAll Dependency) = True isNonLocal _ = False return $ map fst $ filter (isNonLocal . snd) (M.toList targets) buildDepsAndInitialSteps :: HasEnvConfig env => GhciOpts -> [Text] -> RIO env () buildDepsAndInitialSteps GhciOpts{..} targets0 = do let targets = targets0 ++ map T.pack ghciAdditionalPackages -- If necessary, do the build, for local packagee targets, only do -- 'initialBuildSteps'. when (not ghciNoBuild && not (null targets)) $ do eres <- tryAny $ build (const (return ())) Nothing defaultBuildOptsCLI { boptsCLITargets = targets , boptsCLIInitialBuildSteps = True , boptsCLIFlags = ghciFlags , boptsCLIGhcOptions = ghciGhcOptions } case eres of Right () -> return () Left err -> do prettyError $ fromString (show err) prettyWarn "Build failed, but trying to launch GHCi anyway" checkAdditionalPackages :: MonadThrow m => [String] -> m [PackageName] checkAdditionalPackages pkgs = forM pkgs $ \name -> do let mres = (packageIdentifierName <$> parsePackageIdentifierFromString name) <|> parsePackageNameFromString name maybe (throwM $ InvalidPackageOption name) return mres runGhci :: HasEnvConfig env => GhciOpts -> [(PackageName, (Path Abs File, Target))] -> Maybe (Path Abs File) -> [GhciPkgInfo] -> [Path Abs File] -> [PackageName] -> RIO env () runGhci GhciOpts{..} targets mainFile pkgs extraFiles exposePackages = do config <- view configL wc <- view $ actualCompilerVersionL.whichCompilerL let pkgopts = hidePkgOpts ++ genOpts ++ ghcOpts shouldHidePackages = fromMaybe (not (null pkgs && null exposePackages)) ghciHidePackages hidePkgOpts = if shouldHidePackages then ["-hide-all-packages"] ++ -- This is necessary, because current versions of ghci -- will entirely fail to start if base isn't visible. This -- is because it tries to use the interpreter to set -- buffering options on standard IO. (if null targets then ["-package", "base"] else []) ++ concatMap (\n -> ["-package", packageNameString n]) exposePackages else [] oneWordOpts bio | shouldHidePackages = bioOneWordOpts bio ++ bioPackageFlags bio | otherwise = bioOneWordOpts bio genOpts = nubOrd (concatMap (concatMap (oneWordOpts . snd) . ghciPkgOpts) pkgs) (omittedOpts, ghcOpts) = partition badForGhci $ concatMap (concatMap (bioOpts . snd) . ghciPkgOpts) pkgs ++ map T.unpack ( fold (configGhcOptionsByCat config) -- include everything, locals, and targets ++ concatMap (getUserOptions . ghciPkgName) pkgs ) getUserOptions pkg = M.findWithDefault [] pkg (configGhcOptionsByName config) badForGhci x = isPrefixOf "-O" x || elem x (words "-debug -threaded -ticky -static -Werror") unless (null omittedOpts) $ logWarn ("The following GHC options are incompatible with GHCi and have not been passed to it: " <> mconcat (intersperse " " (fromString <$> nubOrd omittedOpts))) oiDir <- view objectInterfaceDirL let odir = [ "-odir=" <> toFilePathNoTrailingSep oiDir , "-hidir=" <> toFilePathNoTrailingSep oiDir ] logInfo $ "Configuring GHCi with the following packages: " <> mconcat (intersperse ", " (map (RIO.display . ghciPkgName) pkgs)) let execGhci extras = do menv <- liftIO $ configProcessContextSettings config defaultEnvSettings withProcessContext menv $ exec (fromMaybe (compilerExeName wc) ghciGhcCommand) (("--interactive" : ) $ -- This initial "-i" resets the include directories to -- not include CWD. If there aren't any packages, CWD -- is included. (if null pkgs then id else ("-i" : )) $ odir <> pkgopts <> extras <> map T.unpack ghciGhcOptions <> ghciArgs) -- TODO: Consider optimizing this check. Perhaps if no -- "with-ghc" is specified, assume that it is not using intero. checkIsIntero = -- Optimization dependent on the behavior of renderScript - -- it doesn't matter if it's intero or ghci when loading -- multiple packages. case pkgs of [_] -> do menv <- liftIO $ configProcessContextSettings config defaultEnvSettings output <- withProcessContext menv $ runGrabFirstLine (fromMaybe (compilerExeName wc) ghciGhcCommand) ["--version"] return $ "Intero" `isPrefixOf` output _ -> return False -- Since usage of 'exec' does not return, we cannot do any cleanup -- on ghci exit. So, instead leave the generated files. To make this -- more efficient and avoid gratuitous generation of garbage, the -- file names are determined by hashing. This also has the nice side -- effect of making it possible to copy the ghci invocation out of -- the log and have it still work. tmpDirectory <- ( $(mkRelDir "haskell-stack-ghci")) <$> (parseAbsDir =<< liftIO getCanonicalTemporaryDirectory) ghciDir <- view ghciDirL ensureDir ghciDir ensureDir tmpDirectory macrosOptions <- writeMacrosFile ghciDir pkgs if ghciNoLoadModules then execGhci macrosOptions else do checkForDuplicateModules pkgs isIntero <- checkIsIntero scriptOptions <- writeGhciScript tmpDirectory (renderScript isIntero pkgs mainFile ghciOnlyMain extraFiles) execGhci (macrosOptions ++ scriptOptions) writeMacrosFile :: HasRunner env => Path Abs Dir -> [GhciPkgInfo] -> RIO env [String] writeMacrosFile outputDirectory pkgs = do fps <- fmap (nubOrd . catMaybes . concat) $ forM pkgs $ \pkg -> forM (ghciPkgOpts pkg) $ \(_, bio) -> do let cabalMacros = bioCabalMacros bio exists <- liftIO $ doesFileExist cabalMacros if exists then return $ Just cabalMacros else do prettyWarnL ["Didn't find expected autogen file:", display cabalMacros] return Nothing files <- liftIO $ mapM (S8.readFile . toFilePath) fps if null files then return [] else do out <- liftIO $ writeHashedFile outputDirectory $(mkRelFile "cabal_macros.h") $ S8.concat $ map (<> "\n#undef CURRENT_PACKAGE_KEY\n#undef CURRENT_COMPONENT_ID\n") files return ["-optP-include", "-optP" <> toFilePath out] writeGhciScript :: (MonadIO m) => Path Abs Dir -> GhciScript -> m [String] writeGhciScript outputDirectory script = do scriptPath <- liftIO $ writeHashedFile outputDirectory $(mkRelFile "ghci-script") $ LBS.toStrict $ scriptToLazyByteString script let scriptFilePath = toFilePath scriptPath setScriptPerms scriptFilePath return ["-ghci-script=" <> scriptFilePath] writeHashedFile :: Path Abs Dir -> Path Rel File -> ByteString -> IO (Path Abs File) writeHashedFile outputDirectory relFile contents = do relSha <- shaPathForBytes contents let outDir = outputDirectory relSha outFile = outDir relFile alreadyExists <- doesFileExist outFile unless alreadyExists $ do ensureDir outDir S8.writeFile (toFilePath outFile) contents return outFile renderScript :: Bool -> [GhciPkgInfo] -> Maybe (Path Abs File) -> Bool -> [Path Abs File] -> GhciScript renderScript isIntero pkgs mainFile onlyMain extraFiles = do let cdPhase = case (isIntero, pkgs) of -- If only loading one package, set the cwd properly. -- Otherwise don't try. See -- https://github.com/commercialhaskell/stack/issues/3309 (True, [pkg]) -> cmdCdGhc (ghciPkgDir pkg) _ -> mempty addPhase = cmdAdd $ S.fromList (map Left allModules ++ addMain) addMain = case mainFile of Just path -> [Right path] _ -> [] modulePhase = cmdModule $ S.fromList allModules allModules = nubOrd $ concatMap (M.keys . ghciPkgModules) pkgs case getFileTargets pkgs <> extraFiles of [] -> if onlyMain then cdPhase <> if isJust mainFile then cmdAdd (S.fromList addMain) else mempty else cdPhase <> addPhase <> modulePhase fileTargets -> cmdAdd (S.fromList (map Right fileTargets)) -- Hacky check if module / main phase should be omitted. This should be -- improved if / when we have a better per-component load. getFileTargets :: [GhciPkgInfo] -> [Path Abs File] getFileTargets = concatMap (concatMap S.toList . maybeToList . ghciPkgTargetFiles) -- | Figure out the main-is file to load based on the targets. Asks the -- user for input if there is more than one candidate main-is file. figureOutMainFile :: HasRunner env => BuildOpts -> Maybe (Map PackageName Target) -> [(PackageName, (Path Abs File, Target))] -> [GhciPkgInfo] -> RIO env (Maybe (Path Abs File)) figureOutMainFile bopts mainIsTargets targets0 packages = do case candidates of [] -> return Nothing [c@(_,_,fp)] -> do logInfo ("Using main module: " <> RIO.display (renderCandidate c)) return (Just fp) candidate:_ -> do borderedWarning $ do logWarn "The main module to load is ambiguous. Candidates are: " forM_ (map renderCandidate candidates) (logWarn . RIO.display) logWarn "You can specify which one to pick by: " logWarn (" * Specifying targets to stack ghci e.g. stack ghci " <> RIO.display ( sampleTargetArg candidate)) logWarn (" * Specifying what the main is e.g. stack ghci " <> RIO.display (sampleMainIsArg candidate)) logWarn (" * Choosing from the candidate above [1.." <> RIO.display (length candidates) <> "]") liftIO userOption where targets = fromMaybe (M.fromList $ map (\(k, (_, x)) -> (k, x)) targets0) mainIsTargets candidates = do pkg <- packages case M.lookup (ghciPkgName pkg) targets of Nothing -> [] Just target -> do (component,mains) <- M.toList $ M.filterWithKey (\k _ -> k `S.member` wantedComponents) (ghciPkgMainIs pkg) main <- S.toList mains return (ghciPkgName pkg, component, main) where wantedComponents = wantedPackageComponents bopts target (ghciPkgPackage pkg) renderCandidate c@(pkgName,namedComponent,mainIs) = let candidateIndex = T.pack . show . (+1) . fromMaybe 0 . elemIndex c in candidateIndex candidates <> ". Package `" <> packageNameText pkgName <> "' component " <> renderComp namedComponent <> " with main-is file: " <> T.pack (toFilePath mainIs) candidateIndices = take (length candidates) [1 :: Int ..] userOption = do option <- prompt "Specify main module to use (press enter to load none): " let selected = fromMaybe ((+1) $ length candidateIndices) (readMaybe (T.unpack option) :: Maybe Int) case elemIndex selected candidateIndices of Nothing -> do putStrLn "Not loading any main modules, as no valid module selected" putStrLn "" return Nothing Just op -> do let (_,_,fp) = candidates !! op putStrLn ("Loading main module from candidate " <> show (op + 1) <> ", --main-is " <> toFilePath fp) putStrLn "" return $ Just fp renderComp c = case c of CLib -> "lib" CInternalLib name -> "internal-lib:" <> name CExe name -> "exe:" <> name CTest name -> "test:" <> name CBench name -> "bench:" <> name sampleTargetArg (pkg,comp,_) = packageNameText pkg <> ":" <> renderComp comp sampleMainIsArg (pkg,comp,_) = "--main-is " <> packageNameText pkg <> ":" <> renderComp comp loadGhciPkgDescs :: HasEnvConfig env => BuildOptsCLI -> [(PackageName, (Path Abs File, Target))] -> RIO env [GhciPkgDesc] loadGhciPkgDescs buildOptsCLI localTargets = forM localTargets $ \(name, (cabalfp, target)) -> loadGhciPkgDesc buildOptsCLI name cabalfp target -- | Load package description information for a ghci target. loadGhciPkgDesc :: HasEnvConfig env => BuildOptsCLI -> PackageName -> Path Abs File -> Target -> RIO env GhciPkgDesc loadGhciPkgDesc buildOptsCLI name cabalfp target = do econfig <- view envConfigL bconfig <- view buildConfigL compilerVersion <- view actualCompilerVersionL let config = PackageConfig { packageConfigEnableTests = True , packageConfigEnableBenchmarks = True , packageConfigFlags = getLocalFlags bconfig buildOptsCLI name , packageConfigGhcOptions = getGhcOptions bconfig buildOptsCLI name True True , packageConfigCompilerVersion = compilerVersion , packageConfigPlatform = view platformL econfig } -- TODO we've already parsed this information, otherwise we -- wouldn't have figured out the cabalfp already. In the future: -- retain that GenericPackageDescription in the relevant data -- structures to avoid reparsing. (gpkgdesc, _cabalfp) <- readPackageUnresolvedDir (parent cabalfp) True -- Source the package's *.buildinfo file created by configure if any. See -- https://www.haskell.org/cabal/users-guide/developing-packages.html#system-dependent-parameters buildinfofp <- parseRelFile (T.unpack (packageNameText name) ++ ".buildinfo") hasDotBuildinfo <- doesFileExist (parent cabalfp buildinfofp) let mbuildinfofp | hasDotBuildinfo = Just (parent cabalfp buildinfofp) | otherwise = Nothing mbuildinfo <- forM mbuildinfofp readDotBuildinfo let pdp = resolvePackageDescription config gpkgdesc pkg = packageFromPackageDescription config (C.genPackageFlags gpkgdesc) $ maybe pdp (\bi -> let PackageDescriptionPair x y = pdp in PackageDescriptionPair (C.updatePackageDescription bi x) (C.updatePackageDescription bi y)) mbuildinfo return GhciPkgDesc { ghciDescPkg = pkg , ghciDescCabalFp = cabalfp , ghciDescTarget = target } getGhciPkgInfos :: HasEnvConfig env => SourceMap -> [PackageName] -> Maybe (Map PackageName (Set (Path Abs File))) -> [GhciPkgDesc] -> RIO env [GhciPkgInfo] getGhciPkgInfos sourceMap addPkgs mfileTargets localTargets = do (installedMap, _, _, _) <- getInstalled GetInstalledOpts { getInstalledProfiling = False , getInstalledHaddock = False , getInstalledSymbols = False } sourceMap let localLibs = [ packageName (ghciDescPkg desc) | desc <- localTargets , hasLocalComp isCLib (ghciDescTarget desc) ] forM localTargets $ \pkgDesc -> makeGhciPkgInfo sourceMap installedMap localLibs addPkgs mfileTargets pkgDesc -- | Make information necessary to load the given package in GHCi. makeGhciPkgInfo :: HasEnvConfig env => SourceMap -> InstalledMap -> [PackageName] -> [PackageName] -> Maybe (Map PackageName (Set (Path Abs File))) -> GhciPkgDesc -> RIO env GhciPkgInfo makeGhciPkgInfo sourceMap installedMap locals addPkgs mfileTargets pkgDesc = do bopts <- view buildOptsL let pkg = ghciDescPkg pkgDesc cabalfp = ghciDescCabalFp pkgDesc target = ghciDescTarget pkgDesc name = packageName pkg (mods,files,opts) <- getPackageOpts (packageOpts pkg) sourceMap installedMap locals addPkgs cabalfp let filteredOpts = filterWanted opts filterWanted = M.filterWithKey (\k _ -> k `S.member` allWanted) allWanted = wantedPackageComponents bopts target pkg setMapMaybe f = S.fromList . mapMaybe f . S.toList return GhciPkgInfo { ghciPkgName = name , ghciPkgOpts = M.toList filteredOpts , ghciPkgDir = parent cabalfp , ghciPkgModules = unionModuleMaps $ map (\(comp, mp) -> M.map (\fp -> M.singleton fp (S.singleton (packageName pkg, comp))) mp) (M.toList (filterWanted mods)) , ghciPkgMainIs = M.map (setMapMaybe dotCabalMainPath) files , ghciPkgCFiles = mconcat (M.elems (filterWanted (M.map (setMapMaybe dotCabalCFilePath) files))) , ghciPkgTargetFiles = mfileTargets >>= M.lookup name , ghciPkgPackage = pkg } -- NOTE: this should make the same choices as the components code in -- 'loadLocalPackage'. Unfortunately for now we reiterate this logic -- (differently). wantedPackageComponents :: BuildOpts -> Target -> Package -> Set NamedComponent wantedPackageComponents _ (TargetComps cs) _ = cs wantedPackageComponents bopts (TargetAll ProjectPackage) pkg = S.fromList $ (case packageLibraries pkg of NoLibraries -> [] HasLibraries names -> CLib : map CInternalLib (S.toList names)) ++ map CExe (S.toList (packageExes pkg)) <> map CInternalLib (S.toList $ packageInternalLibraries pkg) <> (if boptsTests bopts then map CTest (M.keys (packageTests pkg)) else []) <> (if boptsBenchmarks bopts then map CBench (S.toList (packageBenchmarks pkg)) else []) wantedPackageComponents _ _ _ = S.empty checkForIssues :: HasLogFunc env => [GhciPkgInfo] -> RIO env () checkForIssues pkgs = do unless (null issues) $ borderedWarning $ do logWarn "Warning: There are cabal settings for this project which may prevent GHCi from loading your code properly." logWarn "In some cases it can also load some projects which would otherwise fail to build." logWarn "" mapM_ (logWarn . RIO.display) $ intercalate [""] issues logWarn "" logWarn "To resolve, remove the flag(s) from the cabal file(s) and instead put them at the top of the haskell files." logWarn "" logWarn "It isn't yet possible to load multiple packages into GHCi in all cases - see" logWarn "https://ghc.haskell.org/trac/ghc/ticket/10827" where issues = concat [ mixedFlag "-XNoImplicitPrelude" [ "-XNoImplicitPrelude will be used, but GHCi will likely fail to build things which depend on the implicit prelude." ] , mixedFlag "-XCPP" [ "-XCPP will be used, but it can cause issues with multiline strings." , "See https://downloads.haskell.org/~ghc/7.10.2/docs/html/users_guide/options-phases.html#cpp-string-gaps" ] , mixedFlag "-XNoTraditionalRecordSyntax" [ "-XNoTraditionalRecordSyntax will be used, but it break modules which use record syntax." ] , mixedFlag "-XTemplateHaskell" [ "-XTemplateHaskell will be used, but it may cause compilation issues due to different parsing of '$' when there's no space after it." ] , mixedFlag "-XQuasiQuotes" [ "-XQuasiQuotes will be used, but it may cause parse failures due to a different meaning for list comprehension syntax like [x| ... ]" ] , mixedFlag "-XSafe" [ "-XSafe will be used, but it will fail to compile unsafe modules." ] , mixedFlag "-XArrows" [ "-XArrows will be used, but it will cause non-arrow usages of proc, (-<), (-<<) to fail" ] , mixedFlag "-XOverloadedStrings" [ "-XOverloadedStrings will be used, but it can cause type ambiguity in code not usually compiled with it." ] , mixedFlag "-XOverloadedLists" [ "-XOverloadedLists will be used, but it can cause type ambiguity in code not usually compiled with it." ] , mixedFlag "-XMonoLocalBinds" [ "-XMonoLocalBinds will be used, but it can cause type errors in code which expects generalized local bindings." ] , mixedFlag "-XTypeFamilies" [ "-XTypeFamilies will be used, but it implies -XMonoLocalBinds, and so can cause type errors in code which expects generalized local bindings." ] , mixedFlag "-XGADTs" [ "-XGADTs will be used, but it implies -XMonoLocalBinds, and so can cause type errors in code which expects generalized local bindings." ] , mixedFlag "-XNewQualifiedOperators" [ "-XNewQualifiedOperators will be used, but this will break usages of the old qualified operator syntax." ] ] mixedFlag flag msgs = let x = partitionComps (== flag) in [ msgs ++ showWhich x | mixedSettings x ] mixedSettings (xs, ys) = xs /= [] && ys /= [] showWhich (haveIt, don'tHaveIt) = [ "It is specified for:" , " " <> renderPkgComponents haveIt , "But not for: " , " " <> renderPkgComponents don'tHaveIt ] partitionComps f = (map fst xs, map fst ys) where (xs, ys) = partition (any f . snd) compsWithOpts compsWithOpts = map (\(k, bio) -> (k, bioOneWordOpts bio ++ bioOpts bio)) compsWithBios compsWithBios = [ ((ghciPkgName pkg, c), bio) | pkg <- pkgs , (c, bio) <- ghciPkgOpts pkg ] borderedWarning :: HasLogFunc env => RIO env a -> RIO env a borderedWarning f = do logWarn "" logWarn "* * * * * * * *" x <- f logWarn "* * * * * * * *" logWarn "" return x -- TODO: Should this also tell the user the filepaths, not just the -- module name? checkForDuplicateModules :: HasRunner env => [GhciPkgInfo] -> RIO env () checkForDuplicateModules pkgs = do unless (null duplicates) $ do borderedWarning $ do prettyError $ "Multiple files use the same module name:" <> line <> bulletedList (map prettyDuplicate duplicates) throwM LoadingDuplicateModules where duplicates :: [(ModuleName, Map (Path Abs File) (Set (PackageName, NamedComponent)))] duplicates = filter (\(_, mp) -> M.size mp > 1) $ M.toList $ unionModuleMaps (map ghciPkgModules pkgs) prettyDuplicate :: (ModuleName, Map (Path Abs File) (Set (PackageName, NamedComponent))) -> AnsiDoc prettyDuplicate (mn, mp) = styleError (display mn) <+> "found at the following paths" <> line <> bulletedList (map fileDuplicate (M.toList mp)) fileDuplicate :: (Path Abs File, Set (PackageName, NamedComponent)) -> AnsiDoc fileDuplicate (fp, comps) = display fp <+> parens (fillSep (punctuate "," (map display (S.toList comps)))) targetWarnings :: HasRunner env => Path Abs File -> [(PackageName, (Path Abs File, Target))] -> [PackageName] -> Maybe (Map PackageName (Set (Path Abs File)), [Path Abs File]) -> RIO env () targetWarnings stackYaml localTargets nonLocalTargets mfileTargets = do unless (null nonLocalTargets) $ prettyWarnL [ flow "Some targets" , parens $ fillSep $ punctuate "," $ map (styleGood . display) nonLocalTargets , flow "are not local packages, and so cannot be directly loaded." , flow "In future versions of stack, this might be supported - see" , styleUrl "https://github.com/commercialhaskell/stack/issues/1441" , "." , flow "It can still be useful to specify these, as they will be passed to ghci via -package flags." ] when (null localTargets && isNothing mfileTargets) $ prettyNote $ vsep [ flow "No local targets specified, so a plain ghci will be started with no package hiding or package options." , "" , flow "If you want to use package hiding and options, then you can try one of the following:" , "" , bulletedList [ fillSep [ flow "If you want to start a different project configuration than" <+> display stackYaml <> ", then you can use" , styleShell "stack init" , flow "to create a new stack.yaml for the packages in the current directory." , line ] , flow "If you want to use the project configuration at" <+> display stackYaml <> ", then you can add to its 'packages' field." ] , "" ] -- Adds in intermediate dependencies between ghci targets. Note that it -- will return a Lib component for these intermediate dependencies even -- if they don't have a library (but that's fine for the usage within -- this module). -- -- If 'True' is passed for loadAllDeps, this loads all local deps, even -- if they aren't intermediate. getExtraLoadDeps :: Bool -> SourceMap -> [(PackageName, (Path Abs File, Target))] -> [(PackageName, (Path Abs File, Target))] getExtraLoadDeps loadAllDeps sourceMap targets = M.toList $ (\mp -> foldl' (flip M.delete) mp (map fst targets)) $ M.mapMaybe id $ execState (mapM_ (mapM_ go . getDeps . fst) targets) (M.fromList (map (second Just) targets)) where getDeps :: PackageName -> [PackageName] getDeps name = case M.lookup name sourceMap of Just (PSFiles lp _) -> M.keys (packageDeps (lpPackage lp)) -- FIXME just Local? _ -> [] go :: PackageName -> State (Map PackageName (Maybe (Path Abs File, Target))) Bool go name = do cache <- get case (M.lookup name cache, M.lookup name sourceMap) of (Just (Just _), _) -> return True (Just Nothing, _) | not loadAllDeps -> return False (_, Just (PSFiles lp _)) -> do let deps = M.keys (packageDeps (lpPackage lp)) shouldLoad <- liftM or $ mapM go deps if shouldLoad then do modify (M.insert name (Just (lpCabalFile lp, TargetComps (S.singleton CLib)))) return True else do modify (M.insert name Nothing) return False (_, Just PSIndex{}) -> return loadAllDeps (_, _) -> return False setScriptPerms :: MonadIO m => FilePath -> m () #ifdef WINDOWS setScriptPerms _ = do return () #else setScriptPerms fp = do liftIO $ Posix.setFileMode fp $ foldl1 Posix.unionFileModes [ Posix.ownerReadMode , Posix.ownerWriteMode , Posix.groupReadMode , Posix.otherReadMode ] #endif unionTargets :: Ord k => Map k Target -> Map k Target -> Map k Target unionTargets = M.unionWith $ \l r -> case (l, r) of (TargetAll Dependency, _) -> r (TargetComps sl, TargetComps sr) -> TargetComps (S.union sl sr) (TargetComps _, TargetAll ProjectPackage) -> TargetAll ProjectPackage (TargetComps _, _) -> l (TargetAll ProjectPackage, _) -> TargetAll ProjectPackage hasLocalComp :: (NamedComponent -> Bool) -> Target -> Bool hasLocalComp p t = case t of TargetComps s -> any p (S.toList s) TargetAll ProjectPackage -> True _ -> False -- | Run a command and grab the first line of stdout, dropping -- stderr's contexts completely. runGrabFirstLine :: (HasProcessContext env, HasLogFunc env) => String -> [String] -> RIO env String runGrabFirstLine cmd0 args = proc cmd0 args $ \pc -> do (out, _err) <- readProcess_ pc return $ TL.unpack $ TL.filter (/= '\r') $ TL.concat $ take 1 $ TL.lines $ TLE.decodeUtf8With lenientDecode out stack-1.9.3.1/src/Stack/Ghci/Script.hs0000644000000000000000000000511413312026775015473 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude #-} {-# LANGUAGE OverloadedStrings #-} module Stack.Ghci.Script ( GhciScript , ModuleName , cmdAdd , cmdCdGhc , cmdModule , scriptToLazyByteString , scriptToBuilder , scriptToFile ) where import Data.ByteString.Builder (toLazyByteString) import Data.List import qualified Data.Set as S import Path import Stack.Prelude import System.IO (BufferMode (..), hSetBinaryMode) import Distribution.ModuleName hiding (toFilePath) newtype GhciScript = GhciScript { unGhciScript :: [GhciCommand] } instance Semigroup GhciScript where GhciScript xs <> GhciScript ys = GhciScript (ys <> xs) instance Monoid GhciScript where mempty = GhciScript [] mappend = (<>) data GhciCommand = Add (Set (Either ModuleName (Path Abs File))) | CdGhc (Path Abs Dir) | Module (Set ModuleName) deriving (Show) cmdAdd :: Set (Either ModuleName (Path Abs File)) -> GhciScript cmdAdd = GhciScript . (:[]) . Add cmdCdGhc :: Path Abs Dir -> GhciScript cmdCdGhc = GhciScript . (:[]) . CdGhc cmdModule :: Set ModuleName -> GhciScript cmdModule = GhciScript . (:[]) . Module scriptToLazyByteString :: GhciScript -> LByteString scriptToLazyByteString = toLazyByteString . scriptToBuilder scriptToBuilder :: GhciScript -> Builder scriptToBuilder backwardScript = mconcat $ fmap commandToBuilder script where script = reverse $ unGhciScript backwardScript scriptToFile :: Path Abs File -> GhciScript -> IO () scriptToFile path script = withFile filepath WriteMode $ \hdl -> do hSetBuffering hdl (BlockBuffering Nothing) hSetBinaryMode hdl True hPutBuilder hdl (scriptToBuilder script) where filepath = toFilePath path -- Command conversion commandToBuilder :: GhciCommand -> Builder commandToBuilder (Add modules) | S.null modules = mempty | otherwise = ":add " <> mconcat (intersperse " " $ fmap (fromString . quoteFileName . either (mconcat . intersperse "." . components) toFilePath) (S.toAscList modules)) <> "\n" commandToBuilder (CdGhc path) = ":cd-ghc " <> fromString (quoteFileName (toFilePath path)) <> "\n" commandToBuilder (Module modules) | S.null modules = ":module +\n" | otherwise = ":module + " <> mconcat (intersperse " " $ fromString . quoteFileName . mconcat . intersperse "." . components <$> S.toAscList modules) <> "\n" -- | Make sure that a filename with spaces in it gets the proper quotes. quoteFileName :: String -> String quoteFileName x = if ' ' `elem` x then show x else x stack-1.9.3.1/src/Stack/Hoogle.hs0000644000000000000000000002145313455671116014601 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude #-} {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE TemplateHaskell #-} -- | A wrapper around hoogle. module Stack.Hoogle ( hoogleCmd ) where import Stack.Prelude import qualified Data.ByteString.Lazy.Char8 as BL8 import Data.Char (isSpace) import Data.List (find) import qualified Data.Set as Set import qualified Data.Text as T import Path (parseAbsFile) import Path.IO hiding (findExecutable) import qualified Stack.Build import Stack.Fetch import Stack.Runners import Stack.Types.Config import Stack.Types.PackageIdentifier import Stack.Types.PackageName import Stack.Types.Version import System.Exit import RIO.Process -- | Hoogle command. hoogleCmd :: ([String],Bool,Bool,Bool) -> GlobalOpts -> IO () hoogleCmd (args,setup,rebuild,startServer) go = withBuildConfig go $ do hooglePath <- ensureHoogleInPath generateDbIfNeeded hooglePath runHoogle hooglePath args' where args' :: [String] args' = if startServer then ["server", "--local", "--port", "8080"] else [] ++ args generateDbIfNeeded :: Path Abs File -> RIO EnvConfig () generateDbIfNeeded hooglePath = do databaseExists <- checkDatabaseExists if databaseExists && not rebuild then return () else if setup || rebuild then do logWarn (if rebuild then "Rebuilding database ..." else "No Hoogle database yet. Automatically building haddocks and hoogle database (use --no-setup to disable) ...") buildHaddocks logInfo "Built docs." generateDb hooglePath logInfo "Generated DB." else do logError "No Hoogle database. Not building one due to --no-setup" bail generateDb :: Path Abs File -> RIO EnvConfig () generateDb hooglePath = do do dir <- hoogleRoot createDirIfMissing True dir runHoogle hooglePath ["generate", "--local"] buildHaddocks :: RIO EnvConfig () buildHaddocks = liftIO (catch (withBuildConfigAndLock (set (globalOptsBuildOptsMonoidL . buildOptsMonoidHaddockL) (Just True) go) (\lk -> Stack.Build.build (const (return ())) lk defaultBuildOptsCLI)) (\(_ :: ExitCode) -> return ())) hooglePackageName = $(mkPackageName "hoogle") hoogleMinVersion = $(mkVersion "5.0") hoogleMinIdent = PackageIdentifier hooglePackageName hoogleMinVersion installHoogle :: RIO EnvConfig () installHoogle = do hooglePackageIdentifier <- do (_,_,resolved) <- resolvePackagesAllowMissing -- FIXME this Nothing means "do not follow any -- specific snapshot", which matches old -- behavior. However, since introducing the -- logic to pin a name to a package in a -- snapshot, we may arguably want to ensure -- that we're grabbing the version of Hoogle -- present in the snapshot currently being -- used. Nothing mempty (Set.fromList [hooglePackageName]) return (case find ((== hooglePackageName) . packageIdentifierName) (map rpIdent resolved) of Just ident@(PackageIdentifier _ ver) | ver >= hoogleMinVersion -> Right ident _ -> Left hoogleMinIdent) case hooglePackageIdentifier of Left{} -> logInfo $ "Minimum " <> display hoogleMinIdent <> " is not in your index. Installing the minimum version." Right ident -> logInfo $ "Minimum version is " <> display hoogleMinIdent <> ". Found acceptable " <> display ident <> " in your index, installing it." config <- view configL menv <- liftIO $ configProcessContextSettings config envSettings liftIO (catch (withBuildConfigAndLock go (\lk -> Stack.Build.build (const (return ())) lk defaultBuildOptsCLI { boptsCLITargets = [ packageIdentifierText (either id id hooglePackageIdentifier)] })) (\(e :: ExitCode) -> case e of ExitSuccess -> runRIO menv resetExeCache _ -> throwIO e)) runHoogle :: Path Abs File -> [String] -> RIO EnvConfig () runHoogle hooglePath hoogleArgs = do config <- view configL menv <- liftIO $ configProcessContextSettings config envSettings dbpath <- hoogleDatabasePath let databaseArg = ["--database=" ++ toFilePath dbpath] withProcessContext menv $ proc (toFilePath hooglePath) (hoogleArgs ++ databaseArg) runProcess_ bail :: RIO EnvConfig a bail = liftIO (System.Exit.exitWith (ExitFailure (-1))) checkDatabaseExists = do path <- hoogleDatabasePath liftIO (doesFileExist path) ensureHoogleInPath :: RIO EnvConfig (Path Abs File) ensureHoogleInPath = do config <- view configL menv <- liftIO $ configProcessContextSettings config envSettings mhooglePath <- runRIO menv $ findExecutable "hoogle" eres <- case mhooglePath of Left _ -> return $ Left "Hoogle isn't installed." Right hooglePath -> do result <- withProcessContext menv $ proc hooglePath ["--numeric-version"] $ tryAny . fmap fst . readProcess_ let unexpectedResult got = Left $ T.concat [ "'" , T.pack hooglePath , " --numeric-version' did not respond with expected value. Got: " , got ] return $ case result of Left err -> unexpectedResult $ T.pack (show err) Right bs -> case parseVersionFromString (takeWhile (not . isSpace) (BL8.unpack bs)) of Nothing -> unexpectedResult $ T.pack (BL8.unpack bs) Just ver | ver >= hoogleMinVersion -> Right hooglePath | otherwise -> Left $ T.concat [ "Installed Hoogle is too old, " , T.pack hooglePath , " is version " , versionText ver , " but >= 5.0 is required." ] case eres of Right hooglePath -> parseAbsFile hooglePath Left err | setup -> do logWarn $ display err <> " Automatically installing (use --no-setup to disable) ..." installHoogle mhooglePath' <- runRIO menv $ findExecutable "hoogle" case mhooglePath' of Right hooglePath -> parseAbsFile hooglePath Left _ -> do logWarn "Couldn't find hoogle in path after installing. This shouldn't happen, may be a bug." bail | otherwise -> do logWarn $ display err <> " Not installing it due to --no-setup." bail envSettings = EnvSettings { esIncludeLocals = True , esIncludeGhcPackagePath = True , esStackExe = True , esLocaleUtf8 = False , esKeepGhcRts = False } stack-1.9.3.1/src/Stack/IDE.hs0000644000000000000000000000320013455666157013764 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude #-} {-# LANGUAGE ConstraintKinds #-} {-# LANGUAGE FlexibleContexts #-} {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TupleSections #-} -- | Functions for IDEs. module Stack.IDE ( listPackages , listTargets ) where import qualified Data.Map as Map import qualified Data.Set as Set import qualified Data.Text as T import Stack.Config (getLocalPackages) import Stack.Package (readPackageUnresolvedDir, gpdPackageName) import Stack.Prelude import Stack.Types.Config import Stack.Types.NamedComponent -- | List the packages inside the current project. listPackages :: HasEnvConfig env => RIO env () listPackages = do -- TODO: Instead of setting up an entire EnvConfig only to look up the package directories, -- make do with a Config (and the Project inside) and use resolvePackageEntry to get -- the directory. packageDirs <- liftM (map lpvRoot . Map.elems . lpProject) getLocalPackages forM_ packageDirs $ \dir -> do (gpd, _) <- readPackageUnresolvedDir dir False (logInfo . display) (gpdPackageName gpd) -- | List the targets in the current project. listTargets :: HasEnvConfig env => RIO env () listTargets = do rawLocals <- lpProject <$> getLocalPackages logInfo $ display (T.intercalate "\n" (map renderPkgComponent (concatMap toNameAndComponent (Map.toList rawLocals)))) where toNameAndComponent (pkgName,view') = map (pkgName, ) (Set.toList (lpvComponents view')) stack-1.9.3.1/src/Stack/Image.hs0000644000000000000000000002071113455617610014401 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude #-} {-# LANGUAGE ConstraintKinds #-} {-# LANGUAGE DeriveDataTypeable #-} {-# LANGUAGE FlexibleContexts #-} {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE RecordWildCards #-} {-# LANGUAGE TemplateHaskell #-} -- | This module builds Docker (OpenContainer) images. module Stack.Image (stageContainerImageArtifacts, createContainerImageFromStage, imgCmdName, imgDockerCmdName, imgOptsFromMonoid) where import Stack.Prelude import qualified Data.ByteString as B import Data.Char (toLower) import qualified Data.Map.Strict as Map import Data.Text.Encoding (encodeUtf8) import qualified Data.Text as T import Path import Path.Extra import Path.IO import Stack.Constants.Config import Stack.PrettyPrint import Stack.Types.Config import Stack.Types.Image import RIO.Process -- | Stages the executables & additional content in a staging -- directory under '.stack-work' stageContainerImageArtifacts :: HasEnvConfig env => Maybe (Path Abs Dir) -> [Text] -> RIO env () stageContainerImageArtifacts mProjectRoot imageNames = do config <- view configL forM_ (zip [0 ..] (filterImages (map T.unpack imageNames) (imgDockers $ configImage config))) (\(idx,opts) -> do imageDir <- imageStagingDir (fromMaybeProjectRoot mProjectRoot) idx liftIO (ignoringAbsence (removeDirRecur imageDir)) ensureDir imageDir stageExesInDir opts imageDir syncAddContentToDir opts imageDir) -- | Builds a Docker (OpenContainer) image extending the `base` image -- specified in the project's stack.yaml. Then new image will be -- extended with an ENTRYPOINT specified for each `entrypoint` listed -- in the config file. createContainerImageFromStage :: HasConfig env => Maybe (Path Abs Dir) -> [Text] -> RIO env () createContainerImageFromStage mProjectRoot imageNames = do config <- view configL forM_ (zip [0 ..] (filterImages (map T.unpack imageNames) (imgDockers $ configImage config))) (\(idx,opts) -> do imageDir <- imageStagingDir (fromMaybeProjectRoot mProjectRoot) idx createDockerImage opts imageDir extendDockerImageWithEntrypoint opts imageDir) filterImages :: [String] -> [ImageDockerOpts] -> [ImageDockerOpts] filterImages [] = id -- all: no filter filterImages names = filter (imageNameFound . imgDockerImageName) where imageNameFound (Just name) = name `elem` names imageNameFound _ = False -- | Stage all the Package executables in the usr/local/bin -- subdirectory of a temp directory. stageExesInDir :: HasEnvConfig env => ImageDockerOpts -> Path Abs Dir -> RIO env () stageExesInDir opts dir = do srcBinPath <- fmap ( $(mkRelDir "bin")) installationRootLocal let destBinPath = dir $(mkRelDir "usr/local/bin") ensureDir destBinPath case imgDockerExecutables opts of Nothing -> do logInfo "" logInfo "Note: 'executables' not specified for a image container, so every executable in the project's local bin dir will be used." mcontents <- liftIO $ forgivingAbsence $ listDir srcBinPath case mcontents of Just (files, dirs) | not (null files) || not (null dirs) -> liftIO $ copyDirRecur srcBinPath destBinPath _ -> prettyWarn "The project's local bin dir contains no files, so no executables will be added to the docker image." logInfo "" Just exes -> forM_ exes (\exe -> copyFile (srcBinPath exe) (destBinPath exe)) -- | Add any additional files into the temp directory, respecting the -- (Source, Destination) mapping. syncAddContentToDir :: HasEnvConfig env => ImageDockerOpts -> Path Abs Dir -> RIO env () syncAddContentToDir opts dir = do root <- view projectRootL let imgAdd = imgDockerAdd opts forM_ (Map.toList imgAdd) (\(source,destPath) -> do sourcePath <- resolveDir root source let destFullPath = dir dropRoot destPath ensureDir destFullPath liftIO $ copyDirRecur sourcePath destFullPath) -- | Derive an image name from the project directory. imageName :: Path Abs Dir -> String imageName = map toLower . toFilePathNoTrailingSep . dirname -- | Create a general purpose docker image from the temporary -- directory of executables & static content. createDockerImage :: HasConfig env => ImageDockerOpts -> Path Abs Dir -> RIO env () createDockerImage dockerConfig dir = case imgDockerBase dockerConfig of Nothing -> throwM StackImageDockerBaseUnspecifiedException Just base -> do liftIO (B.writeFile (toFilePath (dir $(mkRelFile "Dockerfile"))) (encodeUtf8 (T.pack (unlines ["FROM " ++ base, "ADD ./ /"])))) let args = [ "build" , "-t" , fromMaybe (imageName (parent . parent . parent $ dir)) (imgDockerImageName dockerConfig) , toFilePathNoTrailingSep dir] proc "docker" args runProcess_ -- | Extend the general purpose docker image with entrypoints (if specified). extendDockerImageWithEntrypoint :: HasConfig env => ImageDockerOpts -> Path Abs Dir -> RIO env () extendDockerImageWithEntrypoint dockerConfig dir = do let dockerImageName = fromMaybe (imageName (parent . parent . parent $ dir)) (imgDockerImageName dockerConfig) let imgEntrypoints = imgDockerEntrypoints dockerConfig case imgEntrypoints of Nothing -> return () Just eps -> forM_ eps (\ep -> do liftIO (B.writeFile (toFilePath (dir $(mkRelFile "Dockerfile"))) (encodeUtf8 (T.pack (unlines [ "FROM " ++ dockerImageName , "ENTRYPOINT [\"/usr/local/bin/" ++ ep ++ "\"]" , "CMD []"])))) proc "docker" [ "build" , "-t" , dockerImageName ++ "-" ++ ep , toFilePathNoTrailingSep dir] runProcess_) -- | Fail with friendly error if project root not set. fromMaybeProjectRoot :: Maybe (Path Abs Dir) -> Path Abs Dir fromMaybeProjectRoot = fromMaybe (impureThrow StackImageCannotDetermineProjectRootException) -- | The command name for dealing with images. imgCmdName :: String imgCmdName = "image" -- | The command name for building a docker container. imgDockerCmdName :: String imgDockerCmdName = "container" -- | Convert image opts monoid to image options. imgOptsFromMonoid :: ImageOptsMonoid -> ImageOpts imgOptsFromMonoid ImageOptsMonoid{..} = ImageOpts { imgDockers = imgMonoidDockers } -- | Stack image exceptions. data StackImageException = StackImageDockerBaseUnspecifiedException -- ^ Unspecified parent docker -- container makes building -- impossible | StackImageCannotDetermineProjectRootException -- ^ Can't determine the -- project root (where to -- put image sandbox). deriving (Typeable) instance Exception StackImageException instance Show StackImageException where show StackImageDockerBaseUnspecifiedException = "You must specify a base docker image on which to place your haskell executables." show StackImageCannotDetermineProjectRootException = "Stack was unable to determine the project root in order to build a container." stack-1.9.3.1/src/Stack/Init.hs0000644000000000000000000005602113455617610014265 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude #-} {-# LANGUAGE ConstraintKinds #-} {-# LANGUAGE FlexibleContexts #-} {-# LANGUAGE MultiParamTypeClasses #-} {-# LANGUAGE OverloadedStrings #-} module Stack.Init ( initProject , InitOpts (..) ) where import Stack.Prelude import qualified Data.ByteString.Builder as B import qualified Data.ByteString.Char8 as BC import qualified Data.ByteString.Lazy as L import qualified Data.Foldable as F import qualified Data.HashMap.Strict as HM import qualified Data.IntMap as IntMap import Data.List (intercalate, intersect, maximumBy) import Data.List.NonEmpty (NonEmpty (..)) import qualified Data.List.NonEmpty as NonEmpty import qualified Data.Map.Strict as Map import qualified Data.Set as Set import qualified Data.Text as T import qualified Data.Yaml as Yaml import qualified Distribution.PackageDescription as C import qualified Distribution.Text as C import qualified Distribution.Version as C import Path import Path.Extra (toFilePathNoTrailingSep) import Path.IO import qualified Paths_stack as Meta import Stack.BuildPlan import Stack.Config (getSnapshots, makeConcreteResolver) import Stack.Constants import Stack.Snapshot (loadResolver) import Stack.Solver import Stack.Types.Build import Stack.Types.BuildPlan import Stack.Types.Config import Stack.Types.FlagName import Stack.Types.PackageIdentifier import Stack.Types.PackageName import Stack.Types.Resolver import Stack.Types.Version import qualified System.FilePath as FP -- | Generate stack.yaml initProject :: (HasConfig env, HasGHCVariant env) => WhichSolverCmd -> Path Abs Dir -> InitOpts -> Maybe AbstractResolver -> RIO env () initProject whichCmd currDir initOpts mresolver = do let dest = currDir stackDotYaml reldest <- toFilePath `liftM` makeRelativeToCurrentDir dest exists <- doesFileExist dest when (not (forceOverwrite initOpts) && exists) $ throwString ("Error: Stack configuration file " <> reldest <> " exists, use 'stack solver' to fix the existing config file or \ \'--force' to overwrite it.") dirs <- mapM (resolveDir' . T.unpack) (searchDirs initOpts) let noPkgMsg = "In order to init, you should have an existing .cabal \ \file. Please try \"stack new\" instead." find = findCabalDirs (includeSubDirs initOpts) dirs' = if null dirs then [currDir] else dirs logInfo "Looking for .cabal or package.yaml files to use to init the project." cabaldirs <- Set.toList . Set.unions <$> mapM find dirs' (bundle, dupPkgs) <- cabalPackagesCheck cabaldirs noPkgMsg Nothing (sd, flags, extraDeps, rbundle) <- getDefaultResolver whichCmd dest initOpts mresolver bundle -- Kind of inefficient, since we've already parsed this value. But -- better to reparse in this one case than carry the unneeded data -- around everywhere in the codebase. resolver <- parseCustomLocation (Just (parent dest)) (void (sdResolver sd)) let ignored = Map.difference bundle rbundle dupPkgMsg | dupPkgs /= [] = "Warning (added by new or init): Some packages were found to \ \have names conflicting with others and have been commented \ \out in the packages section.\n" | otherwise = "" missingPkgMsg | Map.size ignored > 0 = "Warning (added by new or init): Some packages were found to \ \be incompatible with the resolver and have been left commented \ \out in the packages section.\n" | otherwise = "" extraDepMsg | Map.size extraDeps > 0 = "Warning (added by new or init): Specified resolver could not \ \satisfy all dependencies. Some external packages have been \ \added as dependencies.\n" | otherwise = "" makeUserMsg msgs = let msg = concat msgs in if msg /= "" then msg <> "You can omit this message by removing it from \ \stack.yaml\n" else "" userMsg = makeUserMsg [dupPkgMsg, missingPkgMsg, extraDepMsg] gpds = Map.elems $ fmap snd rbundle p = Project { projectUserMsg = if userMsg == "" then Nothing else Just userMsg , projectPackages = pkgs , projectDependencies = map (\(n, v) -> PLIndex $ PackageIdentifierRevision (PackageIdentifier n v) CFILatest) (Map.toList extraDeps) , projectFlags = removeSrcPkgDefaultFlags gpds flags , projectResolver = resolver , projectCompiler = Nothing , projectExtraPackageDBs = [] } makeRelDir dir = case stripProperPrefix currDir dir of Nothing | currDir == dir -> "." | otherwise -> assert False $ toFilePathNoTrailingSep dir Just rel -> toFilePathNoTrailingSep rel makeRel = fmap toFilePath . makeRelativeToCurrentDir pkgs = map toPkg $ Map.elems (fmap (parent . fst) rbundle) toPkg dir = PLFilePath $ makeRelDir dir indent t = T.unlines $ fmap (" " <>) (T.lines t) logInfo $ "Initialising configuration using resolver: " <> display (sdResolverName sd) logInfo $ "Total number of user packages considered: " <> display (Map.size bundle + length dupPkgs) when (dupPkgs /= []) $ do logWarn $ "Warning! Ignoring " <> displayShow (length dupPkgs) <> " duplicate packages:" rels <- mapM makeRel dupPkgs logWarn $ display $ indent $ showItems rels when (Map.size ignored > 0) $ do logWarn $ "Warning! Ignoring " <> displayShow (Map.size ignored) <> " packages due to dependency conflicts:" rels <- mapM makeRel (Map.elems (fmap fst ignored)) logWarn $ display $ indent $ showItems rels when (Map.size extraDeps > 0) $ do logWarn $ "Warning! " <> displayShow (Map.size extraDeps) <> " external dependencies were added." logInfo $ (if exists then "Overwriting existing configuration file: " else "Writing configuration to file: ") <> fromString reldest liftIO $ L.writeFile (toFilePath dest) $ B.toLazyByteString $ renderStackYaml p (Map.elems $ fmap (makeRelDir . parent . fst) ignored) (map (makeRelDir . parent) dupPkgs) logInfo "All done." -- | Render a stack.yaml file with comments, see: -- https://github.com/commercialhaskell/stack/issues/226 renderStackYaml :: Project -> [FilePath] -> [FilePath] -> B.Builder renderStackYaml p ignoredPackages dupPackages = case Yaml.toJSON p of Yaml.Object o -> renderObject o _ -> assert False $ B.byteString $ Yaml.encode p where renderObject o = B.byteString headerHelp <> B.byteString "\n\n" <> F.foldMap (goComment o) comments <> goOthers (o `HM.difference` HM.fromList comments) <> B.byteString footerHelp <> "\n" goComment o (name, comment) = case (convert <$> HM.lookup name o) <|> nonPresentValue name of Nothing -> assert (name == "user-message") mempty Just v -> B.byteString comment <> B.byteString "\n" <> v <> if name == "packages" then commentedPackages else "" <> B.byteString "\n" where convert v = B.byteString (Yaml.encode $ Yaml.object [(name, v)]) -- Some fields in stack.yaml are optional and may not be -- generated. For these, we provided commented out dummy -- values to go along with the comments. nonPresentValue "extra-deps" = Just "# extra-deps: []\n" nonPresentValue "flags" = Just "# flags: {}\n" nonPresentValue "extra-package-dbs" = Just "# extra-package-dbs: []\n" nonPresentValue _ = Nothing commentLine l | null l = "#" | otherwise = "# " ++ l commentHelp = BC.pack . intercalate "\n" . map commentLine commentedPackages = let ignoredComment = commentHelp [ "The following packages have been ignored due to incompatibility with the" , "resolver compiler, dependency conflicts with other packages" , "or unsatisfied dependencies." ] dupComment = commentHelp [ "The following packages have been ignored due to package name conflict " , "with other packages." ] in commentPackages ignoredComment ignoredPackages <> commentPackages dupComment dupPackages commentPackages comment pkgs | pkgs /= [] = B.byteString comment <> B.byteString "\n" <> B.byteString (BC.pack $ concat $ map (\x -> "#- " ++ x ++ "\n") pkgs ++ ["\n"]) | otherwise = "" goOthers o | HM.null o = mempty | otherwise = assert False $ B.byteString $ Yaml.encode o -- Per Section Help comments = [ ("user-message" , userMsgHelp) , ("resolver" , resolverHelp) , ("packages" , packageHelp) , ("extra-deps" , "# Dependency packages to be pulled from upstream that are not in the resolver\n# using the same syntax as the packages field.\n# (e.g., acme-missiles-0.3)") , ("flags" , "# Override default flag values for local packages and extra-deps") , ("extra-package-dbs", "# Extra package databases containing global packages") ] -- Help strings headerHelp = commentHelp [ "This file was automatically generated by 'stack init'" , "" , "Some commonly used options have been documented as comments in this file." , "For advanced use and comprehensive documentation of the format, please see:" , "https://docs.haskellstack.org/en/stable/yaml_configuration/" ] resolverHelp = commentHelp [ "Resolver to choose a 'specific' stackage snapshot or a compiler version." , "A snapshot resolver dictates the compiler version and the set of packages" , "to be used for project dependencies. For example:" , "" , "resolver: lts-3.5" , "resolver: nightly-2015-09-21" , "resolver: ghc-7.10.2" , "" , "The location of a snapshot can be provided as a file or url. Stack assumes" , "a snapshot provided as a file might change, whereas a url resource does not." , "" , "resolver: ./custom-snapshot.yaml" , "resolver: https://example.com/snapshots/2018-01-01.yaml" ] userMsgHelp = commentHelp [ "A warning or info to be displayed to the user on config load." ] packageHelp = commentHelp [ "User packages to be built." , "Various formats can be used as shown in the example below." , "" , "packages:" , "- some-directory" , "- https://example.com/foo/bar/baz-0.0.2.tar.gz" , "- location:" , " git: https://github.com/commercialhaskell/stack.git" , " commit: e7b331f14bcffb8367cd58fbfc8b40ec7642100a" , "- location: https://github.com/commercialhaskell/stack/commit/e7b331f14bcffb8367cd58fbfc8b40ec7642100a" , " subdirs:" , " - auto-update" , " - wai" ] footerHelp = let major = toCabalVersion $ toMajorVersion $ fromCabalVersion $ C.mkVersion' Meta.version in commentHelp [ "Control whether we use the GHC we find on the path" , "system-ghc: true" , "" , "Require a specific version of stack, using version ranges" , "require-stack-version: -any # Default" , "require-stack-version: \"" ++ C.display (C.orLaterVersion major) ++ "\"" , "" , "Override the architecture used by stack, especially useful on Windows" , "arch: i386" , "arch: x86_64" , "" , "Extra directories used by stack for building" , "extra-include-dirs: [/path/to/dir]" , "extra-lib-dirs: [/path/to/dir]" , "" , "Allow a newer minor version of GHC than the snapshot specifies" , "compiler-check: newer-minor" ] getSnapshots' :: HasConfig env => RIO env Snapshots getSnapshots' = do getSnapshots `catchAny` \e -> do logError $ "Unable to download snapshot list, and therefore could " <> "not generate a stack.yaml file automatically" logError $ "This sometimes happens due to missing Certificate Authorities " <> "on your system. For more information, see:" logError "" logError " https://github.com/commercialhaskell/stack/issues/234" logError "" logError "You can try again, or create your stack.yaml file by hand. See:" logError "" logError " http://docs.haskellstack.org/en/stable/yaml_configuration/" logError "" logError $ "Exception was: " <> displayShow e throwString "" -- | Get the default resolver value getDefaultResolver :: (HasConfig env, HasGHCVariant env) => WhichSolverCmd -> Path Abs File -- ^ stack.yaml -> InitOpts -> Maybe AbstractResolver -> Map PackageName (Path Abs File, C.GenericPackageDescription) -- ^ Src package name: cabal dir, cabal package description -> RIO env ( SnapshotDef , Map PackageName (Map FlagName Bool) , Map PackageName Version , Map PackageName (Path Abs File, C.GenericPackageDescription)) -- ^ ( Resolver -- , Flags for src packages and extra deps -- , Extra dependencies -- , Src packages actually considered) getDefaultResolver whichCmd stackYaml initOpts mresolver bundle = do sd <- maybe selectSnapResolver (makeConcreteResolver (Just root) >=> loadResolver) mresolver getWorkingResolverPlan whichCmd stackYaml initOpts bundle sd where root = parent stackYaml -- TODO support selecting best across regular and custom snapshots selectSnapResolver = do let gpds = Map.elems (fmap snd bundle) snaps <- fmap getRecommendedSnapshots getSnapshots' (s, r) <- selectBestSnapshot (parent stackYaml) gpds snaps case r of BuildPlanCheckFail {} | not (omitPackages initOpts) -> throwM (NoMatchingSnapshot whichCmd snaps) _ -> return s getWorkingResolverPlan :: (HasConfig env, HasGHCVariant env) => WhichSolverCmd -> Path Abs File -- ^ stack.yaml -> InitOpts -> Map PackageName (Path Abs File, C.GenericPackageDescription) -- ^ Src package name: cabal dir, cabal package description -> SnapshotDef -> RIO env ( SnapshotDef , Map PackageName (Map FlagName Bool) , Map PackageName Version , Map PackageName (Path Abs File, C.GenericPackageDescription)) -- ^ ( SnapshotDef -- , Flags for src packages and extra deps -- , Extra dependencies -- , Src packages actually considered) getWorkingResolverPlan whichCmd stackYaml initOpts bundle sd = do logInfo $ "Selected resolver: " <> display (sdResolverName sd) go bundle where go info = do eres <- checkBundleResolver whichCmd stackYaml initOpts info sd -- if some packages failed try again using the rest case eres of Right (f, edeps)-> return (sd, f, edeps, info) Left ignored | Map.null available -> do logWarn "*** Could not find a working plan for any of \ \the user packages.\nProceeding to create a \ \config anyway." return (sd, Map.empty, Map.empty, Map.empty) | otherwise -> do when (Map.size available == Map.size info) $ error "Bug: No packages to ignore" if length ignored > 1 then do logWarn "*** Ignoring packages:" logWarn $ display $ indent $ showItems ignored else logWarn $ "*** Ignoring package: " <> display (case ignored of [] -> error "getWorkingResolverPlan.head" x:_ -> x) go available where indent t = T.unlines $ fmap (" " <>) (T.lines t) isAvailable k _ = k `notElem` ignored available = Map.filterWithKey isAvailable info checkBundleResolver :: (HasConfig env, HasGHCVariant env) => WhichSolverCmd -> Path Abs File -- ^ stack.yaml -> InitOpts -> Map PackageName (Path Abs File, C.GenericPackageDescription) -- ^ Src package name: cabal dir, cabal package description -> SnapshotDef -> RIO env (Either [PackageName] ( Map PackageName (Map FlagName Bool) , Map PackageName Version)) checkBundleResolver whichCmd stackYaml initOpts bundle sd = do result <- checkSnapBuildPlanActual (parent stackYaml) gpds Nothing sd case result of BuildPlanCheckOk f -> return $ Right (f, Map.empty) BuildPlanCheckPartial f e -> do shouldUseSolver <- case (resolver, initOpts) of (_, InitOpts { useSolver = True }) -> return True (ResolverCompiler _, _) -> do logInfo "Using solver because a compiler resolver was specified." return True _ -> return False if shouldUseSolver then do warnPartial result solve f else if omitPackages initOpts then do warnPartial result logWarn "*** Omitting packages with unsatisfied dependencies" return $ Left $ failedUserPkgs e else throwM $ ResolverPartial whichCmd (sdResolverName sd) (show result) BuildPlanCheckFail _ e _ | omitPackages initOpts -> do logWarn $ "*** Resolver compiler mismatch: " <> display (sdResolverName sd) logWarn $ display $ indent $ T.pack $ show result return $ Left $ failedUserPkgs e | otherwise -> throwM $ ResolverMismatch whichCmd (sdResolverName sd) (show result) where resolver = sdResolver sd indent t = T.unlines $ fmap (" " <>) (T.lines t) warnPartial res = do logWarn $ "*** Resolver " <> display (sdResolverName sd) <> " will need external packages: " logWarn $ display $ indent $ T.pack $ show res failedUserPkgs e = Map.keys $ Map.unions (Map.elems (fmap deNeededBy e)) gpds = Map.elems (fmap snd bundle) solve flags = do let cabalDirs = map parent (Map.elems (fmap fst bundle)) srcConstraints = mergeConstraints (gpdPackages gpds) flags eresult <- solveResolverSpec stackYaml cabalDirs (sd, srcConstraints, Map.empty) case eresult of Right (src, ext) -> return $ Right (fmap snd (Map.union src ext), fmap fst ext) Left packages | omitPackages initOpts, srcpkgs /= []-> do pkg <- findOneIndependent srcpkgs flags return $ Left [pkg] | otherwise -> throwM (SolverGiveUp giveUpMsg) where srcpkgs = Map.keys bundle `intersect` packages -- among a list of packages find one on which none among the rest of the -- packages depend. This package is a good candidate to be removed from -- the list of packages when there is conflict in dependencies among this -- set of packages. findOneIndependent packages flags = do platform <- view platformL (compiler, _) <- getResolverConstraints Nothing stackYaml sd let getGpd pkg = snd (fromMaybe (error "findOneIndependent: getGpd") (Map.lookup pkg bundle)) getFlags pkg = fromMaybe (error "fromOneIndependent: getFlags") (Map.lookup pkg flags) deps pkg = gpdPackageDeps (getGpd pkg) compiler platform (getFlags pkg) allDeps = concatMap (Map.keys . deps) packages isIndependent pkg = pkg `notElem` allDeps -- prefer to reject packages in deeper directories path pkg = fst (fromMaybe (error "findOneIndependent: path") (Map.lookup pkg bundle)) pathlen = length . FP.splitPath . toFilePath . path maxPathlen = maximumBy (compare `on` pathlen) return $ maxPathlen (filter isIndependent packages) giveUpMsg = concat [ " - Use '--omit-packages to exclude conflicting package(s).\n" , " - Tweak the generated " , toFilePath stackDotYaml <> " and then run 'stack solver':\n" , " - Add any missing remote packages.\n" , " - Add extra dependencies to guide solver.\n" , " - Update external packages with 'stack update' and try again.\n" ] getRecommendedSnapshots :: Snapshots -> NonEmpty SnapName getRecommendedSnapshots snapshots = -- in order - Latest LTS, Latest Nightly, all LTS most recent first case NonEmpty.nonEmpty ltss of Just (mostRecent :| older) -> mostRecent :| (nightly : older) Nothing -> nightly :| [] where ltss = map (uncurry LTS) (IntMap.toDescList $ snapshotsLts snapshots) nightly = Nightly (snapshotsNightly snapshots) data InitOpts = InitOpts { searchDirs :: ![T.Text] -- ^ List of sub directories to search for .cabal files , useSolver :: Bool -- ^ Use solver to determine required external dependencies , omitPackages :: Bool -- ^ Exclude conflicting or incompatible user packages , forceOverwrite :: Bool -- ^ Overwrite existing stack.yaml , includeSubDirs :: Bool -- ^ If True, include all .cabal files found in any sub directories } stack-1.9.3.1/src/Stack/Ls.hs0000644000000000000000000002012513455617610013734 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude #-} {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE RecordWildCards #-} {-# LANGUAGE ScopedTypeVariables #-} module Stack.Ls ( lsCmd , lsParser , listDependenciesCmd ) where import Control.Exception (Exception, throw) import Control.Monad.Catch (MonadThrow) import Control.Monad.IO.Class (MonadIO, liftIO) import Control.Monad.Reader (MonadReader) import Control.Monad (when) import Data.Aeson import Stack.Prelude import Stack.Types.Runner import qualified Data.Aeson.Types as A import qualified Data.List as L import Data.Text hiding (pack, intercalate) import qualified Data.Text as T import qualified Data.Text.IO as T import Data.Typeable (Typeable) import qualified Data.Vector as V import Network.HTTP.StackClient (httpJSON, getGlobalManager, addRequestHeader, getResponseBody, parseRequest, setRequestManager, hAccept) import qualified Options.Applicative as OA import Options.Applicative ((<|>)) import Path import Stack.Runners (withBuildConfig, withBuildConfigDot) import Stack.Types.Config import Stack.Dot import Stack.Options.DotParser (listDepsOptsParser) import System.Process.PagerEditor (pageText) import System.Directory (listDirectory) import System.IO (stderr, hPutStrLn) data LsView = Local | Remote deriving (Show, Eq, Ord) data SnapshotType = Lts | Nightly deriving (Show, Eq, Ord) data LsCmds = LsSnapshot SnapshotOpts | LsDependencies ListDepsOpts data SnapshotOpts = SnapshotOpts { soptViewType :: LsView , soptLtsSnapView :: Bool , soptNightlySnapView :: Bool } deriving (Eq, Show, Ord) newtype LsCmdOpts = LsCmdOpts { lsView :: LsCmds } lsParser :: OA.Parser LsCmdOpts lsParser = LsCmdOpts <$> OA.hsubparser (lsSnapCmd <> lsDepsCmd) lsCmdOptsParser :: OA.Parser LsCmds lsCmdOptsParser = LsSnapshot <$> lsViewSnapCmd lsDepOptsParser :: OA.Parser LsCmds lsDepOptsParser = LsDependencies <$> listDepsOptsParser lsViewSnapCmd :: OA.Parser SnapshotOpts lsViewSnapCmd = SnapshotOpts <$> (OA.hsubparser (lsViewRemoteCmd <> lsViewLocalCmd) <|> pure Local) <*> OA.switch (OA.long "lts" <> OA.short 'l' <> OA.help "Only show lts snapshots") <*> OA.switch (OA.long "nightly" <> OA.short 'n' <> OA.help "Only show nightly snapshots") lsSnapCmd :: OA.Mod OA.CommandFields LsCmds lsSnapCmd = OA.command "snapshots" (OA.info lsCmdOptsParser (OA.progDesc "View local snapshot (default option)")) lsDepsCmd :: OA.Mod OA.CommandFields LsCmds lsDepsCmd = OA.command "dependencies" (OA.info lsDepOptsParser (OA.progDesc "View the dependencies")) data Snapshot = Snapshot { snapId :: Text , snapTitle :: Text , snapTime :: Text } deriving (Show, Eq, Ord) data SnapshotData = SnapshotData { _snapTotalCounts :: Integer , snaps :: [[Snapshot]] } deriving (Show, Eq, Ord) instance FromJSON Snapshot where parseJSON o@(Array _) = parseSnapshot o parseJSON _ = mempty instance FromJSON SnapshotData where parseJSON (Object s) = SnapshotData <$> s .: "totalCount" <*> s .: "snapshots" parseJSON _ = mempty toSnapshot :: [Value] -> Snapshot toSnapshot [String sid, String stitle, String stime] = Snapshot { snapId = sid , snapTitle = stitle , snapTime = stime } toSnapshot val = throw $ ParseFailure val newtype LsException = ParseFailure [Value] deriving (Show, Typeable) instance Exception LsException parseSnapshot :: Value -> A.Parser Snapshot parseSnapshot = A.withArray "array of snapshot" (return . toSnapshot . V.toList) displayTime :: Snapshot -> [Text] displayTime Snapshot {..} = [snapTime] displaySnap :: Snapshot -> [Text] displaySnap Snapshot {..} = ["Resolver name: " <> snapId, "\n" <> snapTitle <> "\n\n"] displaySingleSnap :: [Snapshot] -> Text displaySingleSnap snapshots = case snapshots of [] -> mempty (x:xs) -> let snaps = displayTime x <> ["\n\n"] <> displaySnap x <> L.concatMap displaySnap xs in T.concat snaps renderData :: Bool -> Text -> IO () renderData True content = pageText content renderData False content = T.putStr content displaySnapshotData :: Bool -> SnapshotData -> IO () displaySnapshotData term sdata = case L.reverse $ snaps sdata of [] -> return () xs -> let snaps = T.concat $ L.map displaySingleSnap xs in renderData term snaps filterSnapshotData :: SnapshotData -> SnapshotType -> SnapshotData filterSnapshotData sdata stype = sdata { snaps = filterSnapData } where snapdata = snaps sdata filterSnapData = case stype of Lts -> L.map (L.filter (\x -> "lts" `isPrefixOf` snapId x)) snapdata Nightly -> L.map (L.filter (\x -> "nightly" `isPrefixOf` snapId x)) snapdata displayLocalSnapshot :: Bool -> [String] -> IO () displayLocalSnapshot term xs = renderData term (localSnaptoText xs) localSnaptoText :: [String] -> Text localSnaptoText xs = T.intercalate "\n" $ L.map T.pack xs handleLocal :: (MonadIO m, MonadThrow m, MonadReader env m, HasEnvConfig env) => LsCmdOpts -> m () handleLocal lsOpts = do (instRoot :: Path Abs Dir) <- installationRootDeps isStdoutTerminal <- view terminalL let snapRootDir = parent $ parent instRoot snapData' <- liftIO $ listDirectory $ toFilePath snapRootDir let snapData = L.sort snapData' case lsView lsOpts of LsSnapshot SnapshotOpts {..} -> case (soptLtsSnapView, soptNightlySnapView) of (True, False) -> liftIO $ displayLocalSnapshot isStdoutTerminal $ L.filter (L.isPrefixOf "lts") snapData (False, True) -> liftIO $ displayLocalSnapshot isStdoutTerminal $ L.filter (L.isPrefixOf "night") snapData _ -> liftIO $ displayLocalSnapshot isStdoutTerminal snapData LsDependencies _ -> return () handleRemote :: (MonadIO m, MonadThrow m, MonadReader env m, HasEnvConfig env) => LsCmdOpts -> m () handleRemote lsOpts = do req <- liftIO $ parseRequest urlInfo mgr <- liftIO getGlobalManager isStdoutTerminal <- view terminalL let req' = setRequestManager mgr $ addRequestHeader hAccept "application/json" req result <- httpJSON req' let snapData = getResponseBody result case lsView lsOpts of LsSnapshot SnapshotOpts {..} -> case (soptLtsSnapView, soptNightlySnapView) of (True, False) -> liftIO $ displaySnapshotData isStdoutTerminal $ filterSnapshotData snapData Lts (False, True) -> liftIO $ displaySnapshotData isStdoutTerminal $ filterSnapshotData snapData Nightly _ -> liftIO $ displaySnapshotData isStdoutTerminal snapData LsDependencies _ -> return () where urlInfo = "https://www.stackage.org/snapshots" lsCmd :: LsCmdOpts -> GlobalOpts -> IO () lsCmd lsOpts go = case lsView lsOpts of LsSnapshot SnapshotOpts {..} -> case soptViewType of Local -> withBuildConfig go (handleLocal lsOpts) Remote -> withBuildConfig go (handleRemote lsOpts) LsDependencies depOpts -> listDependenciesCmd False depOpts go -- | List the dependencies listDependenciesCmd :: Bool -> ListDepsOpts -> GlobalOpts -> IO () listDependenciesCmd deprecated opts go = do when deprecated (hPutStrLn stderr "DEPRECATED: Use ls dependencies instead. Will be removed in next major version.") withBuildConfigDot (listDepsDotOpts opts) go $ listDependencies opts lsViewLocalCmd :: OA.Mod OA.CommandFields LsView lsViewLocalCmd = OA.command "local" (OA.info (pure Local) (OA.progDesc "View local snapshot")) lsViewRemoteCmd :: OA.Mod OA.CommandFields LsView lsViewRemoteCmd = OA.command "remote" (OA.info (pure Remote) (OA.progDesc "View remote snapshot")) stack-1.9.3.1/src/Stack/New.hs0000644000000000000000000004027713455617610014121 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude #-} {-# LANGUAGE ConstraintKinds #-} {-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE DeriveDataTypeable #-} {-# LANGUAGE FlexibleContexts #-} {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TemplateHaskell #-} -- | Create new a new project directory populated with a basic working -- project. module Stack.New ( new , NewOpts(..) , TemplateName , templatesHelp ) where import Stack.Prelude import Control.Monad.Trans.Writer.Strict import Control.Monad (void) import qualified Data.ByteString.Lazy as LB import Data.Conduit import Data.List import qualified Data.Map.Strict as M import qualified Data.Set as S import qualified Data.Text as T import qualified Data.Text.Lazy as TL import qualified Data.Text.Encoding as T import qualified Data.Text.Lazy.Encoding as TLE import Data.Time.Calendar import Data.Time.Clock import Network.HTTP.Download import Network.HTTP.StackClient (Request, HttpException, getResponseStatusCode, getResponseBody) import Path import Path.IO import Stack.Constants import Stack.Constants.Config import Stack.Types.Config import Stack.Types.PackageName import Stack.Types.TemplateName import RIO.Process import qualified Text.Mustache as Mustache import qualified Text.Mustache.Render as Mustache import Text.ProjectTemplate -------------------------------------------------------------------------------- -- Main project creation -- | Options for creating a new project. data NewOpts = NewOpts { newOptsProjectName :: PackageName -- ^ Name of the project to create. , newOptsCreateBare :: Bool -- ^ Whether to create the project without a directory. , newOptsTemplate :: Maybe TemplateName -- ^ Name of the template to use. , newOptsNonceParams :: Map Text Text -- ^ Nonce parameters specified just for this invocation. } -- | Create a new project with the given options. new :: HasConfig env => NewOpts -> Bool -> RIO env (Path Abs Dir) new opts forceOverwrite = do when (newOptsProjectName opts `elem` wiredInPackages) $ throwM $ Can'tUseWiredInName (newOptsProjectName opts) pwd <- getCurrentDir absDir <- if bare then return pwd else do relDir <- parseRelDir (packageNameString project) liftM (pwd ) (return relDir) exists <- doesDirExist absDir configTemplate <- view $ configL.to configDefaultTemplate let template = fromMaybe defaultTemplateName $ asum [ cliOptionTemplate , configTemplate ] if exists && not bare then throwM (AlreadyExists absDir) else do templateText <- loadTemplate template (logUsing absDir template) files <- applyTemplate project template (newOptsNonceParams opts) absDir templateText when (not forceOverwrite && bare) $ checkForOverwrite (M.keys files) writeTemplateFiles files runTemplateInits absDir return absDir where cliOptionTemplate = newOptsTemplate opts project = newOptsProjectName opts bare = newOptsCreateBare opts logUsing absDir template templateFrom = let loading = case templateFrom of LocalTemp -> "Loading local" RemoteTemp -> "Downloading" in logInfo (loading <> " template \"" <> display (templateName template) <> "\" to create project \"" <> display (packageNameText project) <> "\" in " <> if bare then "the current directory" else fromString (toFilePath (dirname absDir)) <> " ...") data TemplateFrom = LocalTemp | RemoteTemp -- | Download and read in a template's text content. loadTemplate :: forall env. HasConfig env => TemplateName -> (TemplateFrom -> RIO env ()) -> RIO env Text loadTemplate name logIt = do templateDir <- view $ configL.to templatesDir case templatePath name of AbsPath absFile -> logIt LocalTemp >> loadLocalFile absFile UrlPath s -> downloadFromUrl s templateDir RelPath relFile -> catch (do f <- loadLocalFile relFile logIt LocalTemp return f) (\(e :: NewException) -> case relRequest relFile of Just req -> downloadTemplate req (templateDir relFile) Nothing -> throwM e ) RepoPath rtp -> do let url = urlFromRepoTemplatePath rtp downloadFromUrl (T.unpack url) templateDir where loadLocalFile :: Path b File -> RIO env Text loadLocalFile path = do logDebug ("Opening local template: \"" <> fromString (toFilePath path) <> "\"") exists <- doesFileExist path if exists then readFileUtf8 (toFilePath path) else throwM (FailedToLoadTemplate name (toFilePath path)) relRequest :: Path Rel File -> Maybe Request relRequest rel = do rtp <- parseRepoPathWithService defaultRepoService (T.pack (toFilePath rel)) let url = urlFromRepoTemplatePath rtp parseRequest (T.unpack url) downloadFromUrl :: String -> Path Abs Dir -> RIO env Text downloadFromUrl s templateDir = do req <- parseRequest s let rel = fromMaybe backupUrlRelPath (parseRelFile s) downloadTemplate req (templateDir rel) downloadTemplate :: Request -> Path Abs File -> RIO env Text downloadTemplate req path = do logIt RemoteTemp catch (void $ redownload req path) (useCachedVersionOrThrow path) loadLocalFile path useCachedVersionOrThrow :: Path Abs File -> DownloadException -> RIO env () useCachedVersionOrThrow path exception = do exists <- doesFileExist path if exists then do logWarn "Tried to download the template but an error was found." logWarn "Using cached local version. It may not be the most recent version though." else throwM (FailedToDownloadTemplate name exception) backupUrlRelPath = $(mkRelFile "downloaded.template.file.hsfiles") -- | Construct a URL for downloading from a repo. urlFromRepoTemplatePath :: RepoTemplatePath -> Text urlFromRepoTemplatePath (RepoTemplatePath Github user name) = T.concat ["https://raw.githubusercontent.com", "/", user, "/stack-templates/master/", name] urlFromRepoTemplatePath (RepoTemplatePath Gitlab user name) = T.concat ["https://gitlab.com", "/", user, "/stack-templates/raw/master/", name] urlFromRepoTemplatePath (RepoTemplatePath Bitbucket user name) = T.concat ["https://bitbucket.org", "/", user, "/stack-templates/raw/master/", name] -- | Apply and unpack a template into a directory. applyTemplate :: HasConfig env => PackageName -> TemplateName -> Map Text Text -> Path Abs Dir -> Text -> RIO env (Map (Path Abs File) LB.ByteString) applyTemplate project template nonceParams dir templateText = do config <- view configL currentYear <- do now <- liftIO getCurrentTime let (year, _, _) = toGregorian (utctDay now) return $ T.pack . show $ year let context = M.unions [nonceParams, nameParams, configParams, yearParam] where nameAsVarId = T.replace "-" "_" $ packageNameText project nameAsModule = T.filter (/= '-') $ T.toTitle $ packageNameText project nameParams = M.fromList [ ("name", packageNameText project) , ("name-as-varid", nameAsVarId) , ("name-as-module", nameAsModule) ] configParams = configTemplateParams config yearParam = M.singleton "year" currentYear files :: Map FilePath LB.ByteString <- catch (execWriterT $ runConduit $ yield (T.encodeUtf8 templateText) .| unpackTemplate receiveMem id ) (\(e :: ProjectTemplateException) -> throwM (InvalidTemplate template (show e))) when (M.null files) $ throwM (InvalidTemplate template "Template does not contain any files") let isPkgSpec f = ".cabal" `isSuffixOf` f || f == "package.yaml" unless (any isPkgSpec . M.keys $ files) $ throwM (InvalidTemplate template "Template does not contain a .cabal \ \or package.yaml file") -- Apply Mustache templating to a single file within the project -- template. let applyMustache bytes -- Workaround for performance problems with mustache and -- large files, applies to Yesod templates with large -- bootstrap CSS files. See -- https://github.com/commercialhaskell/stack/issues/4133. | LB.length bytes < 50000 , Right text <- TLE.decodeUtf8' bytes = do let etemplateCompiled = Mustache.compileTemplate (T.unpack (templateName template)) $ TL.toStrict text templateCompiled <- case etemplateCompiled of Left e -> throwM $ InvalidTemplate template (show e) Right t -> return t let (substitutionErrors, applied) = Mustache.checkedSubstitute templateCompiled context missingKeys = S.fromList $ concatMap onlyMissingKeys substitutionErrors unless (S.null missingKeys) (logInfo ("\n" <> displayShow (MissingParameters project template missingKeys (configUserConfigPath config)) <> "\n")) pure $ LB.fromStrict $ encodeUtf8 applied -- Too large or too binary | otherwise = pure bytes liftM M.fromList (mapM (\(fpOrig,bytes) -> do -- Apply the mustache template to the filenames -- as well, so that we can have file names -- depend on the project name. fp <- applyMustache $ TLE.encodeUtf8 $ TL.pack fpOrig path <- parseRelFile $ TL.unpack $ TLE.decodeUtf8 fp bytes' <- applyMustache bytes return (dir path, bytes')) (M.toList files)) where onlyMissingKeys (Mustache.VariableNotFound ks) = map T.unpack ks onlyMissingKeys _ = [] -- | Check if we're going to overwrite any existing files. checkForOverwrite :: (MonadIO m, MonadThrow m) => [Path Abs File] -> m () checkForOverwrite files = do overwrites <- filterM doesFileExist files unless (null overwrites) $ throwM (AttemptedOverwrites overwrites) -- | Write files to the new project directory. writeTemplateFiles :: MonadIO m => Map (Path Abs File) LB.ByteString -> m () writeTemplateFiles files = forM_ (M.toList files) (\(fp,bytes) -> do ensureDir (parent fp) liftIO (LB.writeFile (toFilePath fp) bytes)) -- | Run any initialization functions, such as Git. runTemplateInits :: HasConfig env => Path Abs Dir -> RIO env () runTemplateInits dir = do config <- view configL case configScmInit config of Nothing -> return () Just Git -> withWorkingDir (toFilePath dir) $ catchAny (proc "git" ["init"] runProcess_) (\_ -> logInfo "git init failed to run, ignoring ...") -- | Display help for the templates command. templatesHelp :: HasLogFunc env => RIO env () templatesHelp = do let url = defaultTemplatesHelpUrl req <- liftM setGithubHeaders (parseUrlThrow url) resp <- httpLbs req `catch` (throwM . FailedToDownloadTemplatesHelp) case decodeUtf8' $ LB.toStrict $ getResponseBody resp of Left err -> throwM $ BadTemplatesHelpEncoding url err Right txt -> logInfo $ display txt -------------------------------------------------------------------------------- -- Defaults -- | The default template name you can use if you don't have one. defaultTemplateName :: TemplateName defaultTemplateName = $(mkTemplateName "new-template") -- | The default service to use to download templates. defaultRepoService :: RepoService defaultRepoService = Github -- | Default web URL to get the `stack templates` help output. defaultTemplatesHelpUrl :: String defaultTemplatesHelpUrl = "https://raw.githubusercontent.com/commercialhaskell/stack-templates/master/STACK_HELP.md" -------------------------------------------------------------------------------- -- Exceptions -- | Exception that might occur when making a new project. data NewException = FailedToLoadTemplate !TemplateName !FilePath | FailedToDownloadTemplate !TemplateName !DownloadException | AlreadyExists !(Path Abs Dir) | MissingParameters !PackageName !TemplateName !(Set String) !(Path Abs File) | InvalidTemplate !TemplateName !String | AttemptedOverwrites [Path Abs File] | FailedToDownloadTemplatesHelp !HttpException | BadTemplatesHelpEncoding !String -- URL it's downloaded from !UnicodeException | Can'tUseWiredInName !PackageName deriving (Typeable) instance Exception NewException instance Show NewException where show (FailedToLoadTemplate name path) = "Failed to load download template " <> T.unpack (templateName name) <> " from " <> path show (FailedToDownloadTemplate name (RedownloadInvalidResponse _ _ resp)) = case getResponseStatusCode resp of 404 -> "That template doesn't exist. Run `stack templates' to discover available templates." code -> "Failed to download template " <> T.unpack (templateName name) <> ": unknown reason, status code was: " <> show code show (FailedToDownloadTemplate name (RedownloadHttpError httpError)) = "There was an unexpected HTTP error while downloading template " <> T.unpack (templateName name) <> ": " <> show httpError show (AlreadyExists path) = "Directory " <> toFilePath path <> " already exists. Aborting." show (MissingParameters name template missingKeys userConfigPath) = intercalate "\n" [ "The following parameters were needed by the template but not provided: " <> intercalate ", " (S.toList missingKeys) , "You can provide them in " <> toFilePath userConfigPath <> ", like this:" , "templates:" , " params:" , intercalate "\n" (map (\key -> " " <> key <> ": value") (S.toList missingKeys)) , "Or you can pass each one as parameters like this:" , "stack new " <> packageNameString name <> " " <> T.unpack (templateName template) <> " " <> unwords (map (\key -> "-p \"" <> key <> ":value\"") (S.toList missingKeys))] show (InvalidTemplate name why) = "The template \"" <> T.unpack (templateName name) <> "\" is invalid and could not be used. " <> "The error was: " <> why show (AttemptedOverwrites fps) = "The template would create the following files, but they already exist:\n" <> unlines (map ((" " ++) . toFilePath) fps) <> "Use --force to ignore this, and overwite these files." show (FailedToDownloadTemplatesHelp ex) = "Failed to download `stack templates` help. The HTTP error was: " <> show ex show (BadTemplatesHelpEncoding url err) = "UTF-8 decoding error on template info from\n " <> url <> "\n\n" <> show err show (Can'tUseWiredInName name) = "The name \"" <> packageNameString name <> "\" is used by GHC wired-in packages, and so shouldn't be used as a package name" stack-1.9.3.1/src/Stack/Nix.hs0000644000000000000000000001527413455617610014125 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude #-} {-# LANGUAGE ConstraintKinds #-} {-# LANGUAGE DataKinds #-} {-# LANGUAGE DeriveDataTypeable #-} {-# LANGUAGE FlexibleContexts #-} {-# LANGUAGE OverloadedStrings #-} -- | Run commands in a nix-shell module Stack.Nix (reexecWithOptionalShell ,nixCmdName ,nixHelpOptName ) where import Stack.Prelude import qualified Data.Text as T import Data.Version (showVersion) import Lens.Micro (set) import Path.IO import qualified Paths_stack as Meta import Stack.Config (getInNixShell, getInContainer) import Stack.Config.Nix (nixCompiler) import Stack.Constants (platformVariantEnvVar,inNixShellEnvVar,inContainerEnvVar) import Stack.Types.Config import Stack.Types.Docker import Stack.Types.Nix import Stack.Types.Runner import Stack.Types.Compiler import System.Environment (getArgs,getExecutablePath,lookupEnv) import qualified System.FilePath as F import RIO.Process (processContextL, exec) -- | If Nix is enabled, re-runs the currently running OS command in a Nix container. -- Otherwise, runs the inner action. reexecWithOptionalShell :: HasConfig env => Maybe (Path Abs Dir) -> IO (CompilerVersion 'CVWanted) -> IO () -> RIO env () reexecWithOptionalShell mprojectRoot getCompilerVersion inner = do config <- view configL inShell <- getInNixShell inContainer <- getInContainer isReExec <- view reExecL let getCmdArgs = do origArgs <- liftIO getArgs let args | inContainer = origArgs -- internal-re-exec version already passed -- first stack when restarting in the container | otherwise = ("--" ++ reExecArgName ++ "=" ++ showVersion Meta.version) : origArgs exePath <- liftIO getExecutablePath return (exePath, args) if nixEnable (configNix config) && not inShell && (not isReExec || inContainer) then runShellAndExit mprojectRoot getCompilerVersion getCmdArgs else liftIO inner runShellAndExit :: HasConfig env => Maybe (Path Abs Dir) -> IO (CompilerVersion 'CVWanted) -> RIO env (String, [String]) -> RIO env () runShellAndExit mprojectRoot getCompilerVersion getCmdArgs = do config <- view configL envOverride <- view processContextL local (set processContextL envOverride) $ do (cmnd,args) <- fmap (escape *** map escape) getCmdArgs mshellFile <- traverse (resolveFile (fromMaybeProjectRoot mprojectRoot)) $ nixInitFile (configNix config) compilerVersion <- liftIO getCompilerVersion inContainer <- getInContainer ghc <- either throwIO return $ nixCompiler compilerVersion let pkgsInConfig = nixPackages (configNix config) pkgs = pkgsInConfig ++ [ghc, "git", "gcc", "gmp"] pkgsStr = "[" <> T.intercalate " " pkgs <> "]" pureShell = nixPureShell (configNix config) addGCRoots = nixAddGCRoots (configNix config) nixopts = case mshellFile of Just fp -> [toFilePath fp, "--arg", "ghc" ,"with (import {}); " ++ T.unpack ghc] Nothing -> ["-E", T.unpack $ T.concat ["with (import {}); " ,"let inputs = ",pkgsStr,"; " , "libPath = lib.makeLibraryPath inputs; " , "stackExtraArgs = lib.concatMap (pkg: " , "[ ''--extra-lib-dirs=${lib.getLib pkg}/lib'' " , " ''--extra-include-dirs=${lib.getDev pkg}/include'' ]" , ") inputs; in " ,"runCommand ''myEnv'' { " ,"buildInputs = lib.optional stdenv.isLinux glibcLocales ++ inputs; " ,T.pack platformVariantEnvVar <> "=''nix''; " ,T.pack inNixShellEnvVar <> "=1; " ,if inContainer -- If shell is pure, this env var would not -- be seen by stack inside nix then T.pack inContainerEnvVar <> "=1; " else "" ,"LD_LIBRARY_PATH = libPath;" -- LD_LIBRARY_PATH is set because for now it's -- needed by builds using Template Haskell ,"STACK_IN_NIX_EXTRA_ARGS = stackExtraArgs; " ,"} \"\""]] -- glibcLocales is necessary on Linux to avoid warnings about GHC being incapable to set the locale. fullArgs = concat [if pureShell then ["--pure"] else [] ,if addGCRoots then ["--indirect", "--add-root" ,toFilePath (configWorkDir config) F. "nix-gc-symlinks" F. "gc-root"] else [] ,map T.unpack (nixShellOptions (configNix config)) ,nixopts ,["--run", unwords (cmnd:"$STACK_IN_NIX_EXTRA_ARGS":args)] ] -- Using --run instead of --command so we cannot -- end up in the nix-shell if stack build is Ctrl-C'd pathVar <- liftIO $ lookupEnv "PATH" logDebug $ "PATH is: " <> displayShow pathVar logDebug $ "Using a nix-shell environment " <> (case mshellFile of Just path -> "from file: " <> fromString (toFilePath path) Nothing -> "with nix packages: " <> display (T.intercalate ", " pkgs)) exec "nix-shell" fullArgs -- | Shell-escape quotes inside the string and enclose it in quotes. escape :: String -> String escape str = "'" ++ foldr (\c -> if c == '\'' then ("'\"'\"'"++) else (c:)) "" str ++ "'" -- | Fail with friendly error if project root not set. fromMaybeProjectRoot :: Maybe (Path Abs Dir) -> Path Abs Dir fromMaybeProjectRoot = fromMaybe (impureThrow CannotDetermineProjectRoot) -- | Command-line argument for "nix" nixCmdName :: String nixCmdName = "nix" nixHelpOptName :: String nixHelpOptName = nixCmdName ++ "-help" -- | Exceptions thrown by "Stack.Nix". data StackNixException = CannotDetermineProjectRoot -- ^ Can't determine the project root (location of the shell file if any). deriving (Typeable) instance Exception StackNixException instance Show StackNixException where show CannotDetermineProjectRoot = "Cannot determine project root directory." stack-1.9.3.1/src/Stack/Options/BenchParser.hs0000644000000000000000000000207113344044236017200 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude #-} {-# LANGUAGE OverloadedStrings #-} module Stack.Options.BenchParser where import Options.Applicative import Options.Applicative.Builder.Extra import Stack.Prelude import Stack.Options.Utils import Stack.Types.Config -- | Parser for bench arguments. -- FIXME hiding options benchOptsParser :: Bool -> Parser BenchmarkOptsMonoid benchOptsParser hide0 = BenchmarkOptsMonoid <$> optionalFirst (strOption (long "benchmark-arguments" <> long "ba" <> metavar "BENCH_ARGS" <> help ("Forward BENCH_ARGS to the benchmark suite. " <> "Supports templates from `cabal bench`") <> hide)) <*> optionalFirst (flag' True (long "no-run-benchmarks" <> help "Disable running of benchmarks. (Benchmarks will still be built.)" <> hide)) where hide = hideMods hide0 stack-1.9.3.1/src/Stack/Options/BuildMonoidParser.hs0000644000000000000000000001431413455617610020376 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude #-} module Stack.Options.BuildMonoidParser where import qualified Data.Text as T import Options.Applicative import Options.Applicative.Builder.Extra import Stack.Build (splitObjsWarning) import Stack.Prelude import Stack.Options.BenchParser import Stack.Options.TestParser import Stack.Options.HaddockParser import Stack.Options.Utils import Stack.Types.Config.Build buildOptsMonoidParser :: GlobalOptsContext -> Parser BuildOptsMonoid buildOptsMonoidParser hide0 = BuildOptsMonoid <$> trace' <*> profile <*> noStrip <*> libProfiling <*> exeProfiling <*> libStripping <*> exeStripping <*> haddock <*> haddockOptsParser hideBool <*> openHaddocks <*> haddockDeps <*> haddockInternal <*> haddockHyperlinkSource <*> copyBins <*> copyCompilerTool <*> preFetch <*> keepGoing <*> keepTmpFiles <*> forceDirty <*> tests <*> testOptsParser hideBool <*> benches <*> benchOptsParser hideBool <*> reconfigure <*> cabalVerbose <*> splitObjs <*> skipComponents <*> interleavedOutput where hideBool = hide0 /= BuildCmdGlobalOpts hide = hideMods hideBool hideExceptGhci = hideMods (hide0 `notElem` [BuildCmdGlobalOpts, GhciCmdGlobalOpts]) -- These use 'Any' because they are not settable in stack.yaml, so -- there is no need for options like --no-profile. trace' = Any <$> flag False True (long "trace" <> help "Enable profiling in libraries, executables, etc. \ \for all expressions and generate a backtrace on \ \exception" <> hideExceptGhci) profile = Any <$> flag False True (long "profile" <> help "profiling in libraries, executables, etc. \ \for all expressions and generate a profiling report\ \ in tests or benchmarks" <> hideExceptGhci) noStrip = Any <$> flag False True (long "no-strip" <> help "Disable DWARF debugging symbol stripping in libraries, \ \executables, etc. for all expressions, producing \ \larger executables but allowing the use of standard \ \debuggers/profiling tools/other utilities that use \ \debugging symbols." <> hideExceptGhci) libProfiling = firstBoolFlags "library-profiling" "library profiling for TARGETs and all its dependencies" hide exeProfiling = firstBoolFlags "executable-profiling" "executable profiling for TARGETs and all its dependencies" hide libStripping = firstBoolFlags "library-stripping" "library stripping for TARGETs and all its dependencies" hide exeStripping = firstBoolFlags "executable-stripping" "executable stripping for TARGETs and all its dependencies" hide haddock = firstBoolFlags "haddock" "generating Haddocks the package(s) in this directory/configuration" hide openHaddocks = firstBoolFlags "open" "opening the local Haddock documentation in the browser" hide haddockDeps = firstBoolFlags "haddock-deps" "building Haddocks for dependencies" hide haddockInternal = firstBoolFlags "haddock-internal" "building Haddocks for internal modules (like cabal haddock --internal)" hide haddockHyperlinkSource = firstBoolFlags "haddock-hyperlink-source" "building hyperlinked source for Haddock (like haddock --hyperlinked-source)" hide copyBins = firstBoolFlags "copy-bins" "copying binaries to the local-bin-path (see 'stack path')" hide copyCompilerTool = firstBoolFlags "copy-compiler-tool" "copying binaries of targets to compiler-tools-bin (see 'stack path')" hide keepGoing = firstBoolFlags "keep-going" "continue running after a step fails (default: false for build, true for test/bench)" hide keepTmpFiles = firstBoolFlags "keep-tmp-files" "keep intermediate files and build directories (default: false)" hide preFetch = firstBoolFlags "prefetch" "Fetch packages necessary for the build immediately, useful with --dry-run" hide forceDirty = firstBoolFlags "force-dirty" "Force treating all local packages as having dirty files (useful for cases where stack can't detect a file change" hide tests = firstBoolFlags "test" "testing the package(s) in this directory/configuration" hideExceptGhci benches = firstBoolFlags "bench" "benchmarking the package(s) in this directory/configuration" hideExceptGhci reconfigure = firstBoolFlags "reconfigure" "Perform the configure step even if unnecessary. Useful in some corner cases with custom Setup.hs files" hide cabalVerbose = firstBoolFlags "cabal-verbose" "Ask Cabal to be verbose in its output" hide splitObjs = firstBoolFlags "split-objs" ("Enable split-objs, to reduce output size (at the cost of build time). " ++ splitObjsWarning) hide skipComponents = many (fmap T.pack (strOption (long "skip" <> help "Skip given component, can be specified multiple times" <> hide))) interleavedOutput = firstBoolFlags "interleaved-output" "Print concurrent GHC output to the console with a prefix for the package name" hide stack-1.9.3.1/src/Stack/Options/BuildParser.hs0000644000000000000000000000711513455617610017231 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude #-} {-# LANGUAGE OverloadedStrings #-} module Stack.Options.BuildParser where import qualified Data.Map as Map import Options.Applicative import Options.Applicative.Args import Options.Applicative.Builder.Extra import Stack.Options.Completion import Stack.Options.PackageParser (readFlag) import Stack.Prelude import Stack.Types.Config import Stack.Types.FlagName import Stack.Types.PackageName import Stack.Types.Version -- | Parser for CLI-only build arguments buildOptsParser :: BuildCommand -> Parser BuildOptsCLI buildOptsParser cmd = BuildOptsCLI <$> targetsParser <*> switch (long "dry-run" <> help "Don't build anything, just prepare to") <*> ((\x y z -> concat [x, y, z]) <$> flag [] ["-Wall", "-Werror"] (long "pedantic" <> help "Turn on -Wall and -Werror") <*> flag [] ["-O0"] (long "fast" <> help "Turn off optimizations (-O0)") <*> many (textOption (long "ghc-options" <> metavar "OPTIONS" <> completer ghcOptsCompleter <> help "Additional options passed to GHC"))) <*> flagsParser <*> (flag' BSOnlyDependencies (long "dependencies-only" <> help "A synonym for --only-dependencies") <|> flag' BSOnlySnapshot (long "only-snapshot" <> help "Only build packages for the snapshot database, not the local database") <|> flag' BSOnlyDependencies (long "only-dependencies" <> help "Only build packages that are dependencies of targets on the command line") <|> pure BSAll) <*> (flag' FileWatch (long "file-watch" <> help "Watch for changes in local files and automatically rebuild. Ignores files in VCS boring/ignore file") <|> flag' FileWatchPoll (long "file-watch-poll" <> help "Like --file-watch, but polling the filesystem instead of using events") <|> pure NoFileWatch) <*> many (cmdOption (long "exec" <> metavar "CMD [ARGS]" <> help "Command and arguments to run after a successful build")) <*> switch (long "only-configure" <> help "Only perform the configure step, not any builds. Intended for tool usage, may break when used on multiple packages at once!") <*> pure cmd <*> switch (long "initial-build-steps" <> help "For target packages, only run initial build steps needed for GHCi" <> internal) targetsParser :: Parser [Text] targetsParser = many (textArgument (metavar "TARGET" <> completer targetCompleter <> help ("If none specified, use all local packages. " <> "See https://docs.haskellstack.org/en/v" <> versionString stackMinorVersion <> "/build_command/#target-syntax for details."))) flagsParser :: Parser (Map.Map (Maybe PackageName) (Map.Map FlagName Bool)) flagsParser = Map.unionsWith Map.union <$> many (option readFlag (long "flag" <> completer flagCompleter <> metavar "PACKAGE:[-]FLAG" <> help ("Override flags set in stack.yaml " <> "(applies to local packages and extra-deps)"))) stack-1.9.3.1/src/Stack/Options/CleanParser.hs0000644000000000000000000000135313455617610017212 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude #-} module Stack.Options.CleanParser where import Options.Applicative import Stack.Clean (CleanOpts (..)) import Stack.Prelude import Stack.Types.PackageName -- | Command-line parser for the clean command. cleanOptsParser :: Parser CleanOpts cleanOptsParser = CleanShallow <$> packages <|> doFullClean where packages = many (packageNameArgument (metavar "PACKAGE" <> help "If none specified, clean all local packages")) doFullClean = flag' CleanFull (long "full" <> help "Delete all work directories (.stack-work by default) in the project") stack-1.9.3.1/src/Stack/Options/ConfigParser.hs0000644000000000000000000001412213455617610017373 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude #-} module Stack.Options.ConfigParser where import Data.Char import qualified Data.Set as Set import Options.Applicative import Options.Applicative.Builder.Extra import Path import Stack.Constants import Stack.Options.BuildMonoidParser import Stack.Options.DockerParser import Stack.Options.GhcBuildParser import Stack.Options.GhcVariantParser import Stack.Options.NixParser import Stack.Options.Utils import Stack.Prelude import Stack.Types.Config import qualified System.FilePath as FilePath -- | Command-line arguments parser for configuration. configOptsParser :: FilePath -> GlobalOptsContext -> Parser ConfigMonoid configOptsParser currentDir hide0 = (\stackRoot workDir buildOpts dockerOpts nixOpts systemGHC installGHC arch ghcVariant ghcBuild jobs includes libs overrideGccPath overrideHpack skipGHCCheck skipMsys localBin modifyCodePage allowDifferentUser dumpLogs -> mempty { configMonoidStackRoot = stackRoot , configMonoidWorkDir = workDir , configMonoidBuildOpts = buildOpts , configMonoidDockerOpts = dockerOpts , configMonoidNixOpts = nixOpts , configMonoidSystemGHC = systemGHC , configMonoidInstallGHC = installGHC , configMonoidSkipGHCCheck = skipGHCCheck , configMonoidArch = arch , configMonoidGHCVariant = ghcVariant , configMonoidGHCBuild = ghcBuild , configMonoidJobs = jobs , configMonoidExtraIncludeDirs = includes , configMonoidExtraLibDirs = libs , configMonoidOverrideGccPath = overrideGccPath , configMonoidOverrideHpack = overrideHpack , configMonoidSkipMsys = skipMsys , configMonoidLocalBinPath = localBin , configMonoidModifyCodePage = modifyCodePage , configMonoidAllowDifferentUser = allowDifferentUser , configMonoidDumpLogs = dumpLogs }) <$> optionalFirst (absDirOption ( long stackRootOptionName <> metavar (map toUpper stackRootOptionName) <> help ("Absolute path to the global stack root directory " ++ "(Overrides any STACK_ROOT environment variable)") <> hide )) <*> optionalFirst (option (eitherReader (mapLeft showWorkDirError . parseRelDir)) ( long "work-dir" <> metavar "WORK-DIR" <> completer (pathCompleterWith (defaultPathCompleterOpts { pcoAbsolute = False, pcoFileFilter = const False })) <> help ("Relative path of work directory " ++ "(Overrides any STACK_WORK environment variable, default is '.stack-work')") <> hide )) <*> buildOptsMonoidParser hide0 <*> dockerOptsParser True <*> nixOptsParser True <*> firstBoolFlags "system-ghc" "using the system installed GHC (on the PATH) if it is available and its version matches. Disabled by default." hide <*> firstBoolFlags "install-ghc" "downloading and installing GHC if necessary (can be done manually with stack setup)" hide <*> optionalFirst (strOption ( long "arch" <> metavar "ARCH" <> help "System architecture, e.g. i386, x86_64" <> hide )) <*> optionalFirst (ghcVariantParser (hide0 /= OuterGlobalOpts)) <*> optionalFirst (ghcBuildParser (hide0 /= OuterGlobalOpts)) <*> optionalFirst (option auto ( long "jobs" <> short 'j' <> metavar "JOBS" <> help "Number of concurrent jobs to run" <> hide )) <*> fmap Set.fromList (many ((currentDir FilePath.) <$> strOption ( long "extra-include-dirs" <> metavar "DIR" <> completer dirCompleter <> help "Extra directories to check for C header files" <> hide ))) <*> fmap Set.fromList (many ((currentDir FilePath.) <$> strOption ( long "extra-lib-dirs" <> metavar "DIR" <> completer dirCompleter <> help "Extra directories to check for libraries" <> hide ))) <*> optionalFirst (absFileOption ( long "with-gcc" <> metavar "PATH-TO-GCC" <> help "Use gcc found at PATH-TO-GCC" <> hide )) <*> optionalFirst (strOption ( long "with-hpack" <> metavar "HPACK" <> help "Use HPACK executable (overrides bundled Hpack)" <> hide )) <*> firstBoolFlags "skip-ghc-check" "skipping the GHC version and architecture check" hide <*> firstBoolFlags "skip-msys" "skipping the local MSYS installation (Windows only)" hide <*> optionalFirst (strOption ( long "local-bin-path" <> metavar "DIR" <> completer dirCompleter <> help "Install binaries to DIR" <> hide )) <*> firstBoolFlags "modify-code-page" "setting the codepage to support UTF-8 (Windows only)" hide <*> firstBoolFlags "allow-different-user" ("permission for users other than the owner of the stack root " ++ "directory to use a stack installation (POSIX only)") hide <*> fmap toDumpLogs (firstBoolFlags "dump-logs" "dump the build output logs for local packages to the console" hide) where hide = hideMods (hide0 /= OuterGlobalOpts) toDumpLogs (First (Just True)) = First (Just DumpAllLogs) toDumpLogs (First (Just False)) = First (Just DumpNoLogs) toDumpLogs (First Nothing) = First Nothing showWorkDirError err = show err ++ "\nNote that --work-dir must be a relative child directory, because work-dirs outside of the package are not supported by Cabal." ++ "\nSee https://github.com/commercialhaskell/stack/issues/2954" stack-1.9.3.1/src/Stack/Options/Completion.hs0000644000000000000000000001057713455617610017134 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude #-} {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TemplateHaskell #-} {-# LANGUAGE TupleSections #-} module Stack.Options.Completion ( ghcOptsCompleter , targetCompleter , flagCompleter , projectExeCompleter ) where import Data.Char (isSpace) import Data.List (isPrefixOf) import qualified Data.Map as Map import Data.Maybe import qualified Data.Set as Set import qualified Data.Text as T import qualified Distribution.PackageDescription as C import qualified Distribution.Types.UnqualComponentName as C import Options.Applicative import Options.Applicative.Builder.Extra import Stack.Config (getLocalPackages) import Stack.DefaultColorWhen (defaultColorWhen) import Stack.Options.GlobalParser (globalOptsFromMonoid) import Stack.Runners (loadConfigWithOpts) import Stack.Prelude hiding (lift) import Stack.Setup import Stack.Types.Config import Stack.Types.FlagName import Stack.Types.NamedComponent import Stack.Types.PackageName import System.Process (readProcess) import Language.Haskell.TH.Syntax (runIO, lift) ghcOptsCompleter :: Completer ghcOptsCompleter = mkCompleter $ \inputRaw -> return $ let input = unescapeBashArg inputRaw (curArgReversed, otherArgsReversed) = break isSpace (reverse input) curArg = reverse curArgReversed otherArgs = reverse otherArgsReversed in if null curArg then [] else map (otherArgs ++) $ filter (curArg `isPrefixOf`) -- Technically, we should be consulting the user's current ghc, -- but that would require loading up a BuildConfig. $(runIO (readProcess "ghc" ["--show-options"] "") >>= lift . lines) -- TODO: Ideally this would pay attention to --stack-yaml, may require -- changes to optparse-applicative. buildConfigCompleter :: (String -> RIO EnvConfig [String]) -> Completer buildConfigCompleter inner = mkCompleter $ \inputRaw -> do let input = unescapeBashArg inputRaw case input of -- If it looks like a flag, skip this more costly completion. ('-': _) -> return [] _ -> do defColorWhen <- liftIO defaultColorWhen let go = (globalOptsFromMonoid False defColorWhen mempty) { globalLogLevel = LevelOther "silent" } loadConfigWithOpts go $ \lc -> do bconfig <- liftIO $ lcLoadBuildConfig lc (globalCompiler go) envConfig <- runRIO bconfig (setupEnv Nothing) runRIO envConfig (inner input) targetCompleter :: Completer targetCompleter = buildConfigCompleter $ \input -> filter (input `isPrefixOf`) . concatMap allComponentNames . Map.toList . lpProject <$> getLocalPackages where allComponentNames (name, lpv) = map (T.unpack . renderPkgComponent . (name,)) (Set.toList (lpvComponents lpv)) flagCompleter :: Completer flagCompleter = buildConfigCompleter $ \input -> do lpvs <- fmap lpProject getLocalPackages bconfig <- view buildConfigL let wildcardFlags = nubOrd $ concatMap (\(name, lpv) -> map (\fl -> "*:" ++ flagString name fl) (C.genPackageFlags (lpvGPD lpv))) $ Map.toList lpvs normalFlags = concatMap (\(name, lpv) -> map (\fl -> packageNameString name ++ ":" ++ flagString name fl) (C.genPackageFlags (lpvGPD lpv))) $ Map.toList lpvs flagString name fl = let flname = C.unFlagName $ C.flagName fl in (if flagEnabled name fl then "-" else "") ++ flname flagEnabled name fl = fromMaybe (C.flagDefault fl) $ Map.lookup (fromCabalFlagName (C.flagName fl)) $ Map.findWithDefault Map.empty name (bcFlags bconfig) return $ filter (input `isPrefixOf`) $ case input of ('*' : ':' : _) -> wildcardFlags ('*' : _) -> wildcardFlags _ -> normalFlags projectExeCompleter :: Completer projectExeCompleter = buildConfigCompleter $ \input -> filter (input `isPrefixOf`) . nubOrd . concatMap (\(_, lpv) -> map (C.unUnqualComponentName . fst) (C.condExecutables (lpvGPD lpv)) ) . Map.toList . lpProject <$> getLocalPackages stack-1.9.3.1/src/Stack/Options/DockerParser.hs0000644000000000000000000001532013455617610017376 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude #-} module Stack.Options.DockerParser where import Data.Char import Data.List (intercalate) import qualified Data.Text as T import Distribution.Version (anyVersion) import Options.Applicative import Options.Applicative.Args import Options.Applicative.Builder.Extra import Stack.Constants import Stack.Docker import qualified Stack.Docker as Docker import Stack.Prelude import Stack.Options.Utils import Stack.Types.Version import Stack.Types.Docker -- | Options parser configuration for Docker. dockerOptsParser :: Bool -> Parser DockerOptsMonoid dockerOptsParser hide0 = DockerOptsMonoid <$> pure (Any False) <*> firstBoolFlags dockerCmdName "using a Docker container. --docker implies 'system-ghc: true'" hide <*> fmap First (Just . DockerMonoidRepo <$> option str (long (dockerOptName dockerRepoArgName) <> hide <> metavar "NAME" <> help "Docker repository name") <|> Just . DockerMonoidImage <$> option str (long (dockerOptName dockerImageArgName) <> hide <> metavar "IMAGE" <> help "Exact Docker image ID (overrides docker-repo)") <|> pure Nothing) <*> firstBoolFlags (dockerOptName dockerRegistryLoginArgName) "registry requires login" hide <*> firstStrOption (long (dockerOptName dockerRegistryUsernameArgName) <> hide <> metavar "USERNAME" <> help "Docker registry username") <*> firstStrOption (long (dockerOptName dockerRegistryPasswordArgName) <> hide <> metavar "PASSWORD" <> help "Docker registry password") <*> firstBoolFlags (dockerOptName dockerAutoPullArgName) "automatic pulling latest version of image" hide <*> firstBoolFlags (dockerOptName dockerDetachArgName) "running a detached Docker container" hide <*> firstBoolFlags (dockerOptName dockerPersistArgName) "not deleting container after it exits" hide <*> firstStrOption (long (dockerOptName dockerContainerNameArgName) <> hide <> metavar "NAME" <> help "Docker container name") <*> argsOption (long (dockerOptName dockerRunArgsArgName) <> hide <> value [] <> metavar "'ARG1 [ARG2 ...]'" <> help "Additional options to pass to 'docker run'") <*> many (option auto (long (dockerOptName dockerMountArgName) <> hide <> metavar "(PATH | HOST-PATH:CONTAINER-PATH)" <> completer dirCompleter <> help ("Mount volumes from host in container " ++ "(may specify multiple times)"))) <*> many (option str (long (dockerOptName dockerEnvArgName) <> hide <> metavar "NAME=VALUE" <> help ("Set environment variable in container " ++ "(may specify multiple times)"))) <*> optionalFirst (absFileOption (long (dockerOptName dockerDatabasePathArgName) <> hide <> metavar "PATH" <> help "Location of image usage tracking database")) <*> optionalFirst (option (eitherReader' parseDockerStackExe) (let specialOpts = [ dockerStackExeDownloadVal , dockerStackExeHostVal , dockerStackExeImageVal ] in long(dockerOptName dockerStackExeArgName) <> hide <> metavar (intercalate "|" (specialOpts ++ ["PATH"])) <> completer (listCompleter specialOpts <> fileCompleter) <> help (concat [ "Location of " , stackProgName , " executable used in container" ]))) <*> firstBoolFlags (dockerOptName dockerSetUserArgName) "setting user in container to match host" hide <*> pure (IntersectingVersionRange anyVersion) where dockerOptName optName = dockerCmdName ++ "-" ++ T.unpack optName firstStrOption = optionalFirst . option str hide = hideMods hide0 -- | Parser for docker cleanup arguments. dockerCleanupOptsParser :: Parser Docker.CleanupOpts dockerCleanupOptsParser = Docker.CleanupOpts <$> (flag' Docker.CleanupInteractive (short 'i' <> long "interactive" <> help "Show cleanup plan in editor and allow changes (default)") <|> flag' Docker.CleanupImmediate (short 'y' <> long "immediate" <> help "Immediately execute cleanup plan") <|> flag' Docker.CleanupDryRun (short 'n' <> long "dry-run" <> help "Display cleanup plan but do not execute") <|> pure Docker.CleanupInteractive) <*> opt (Just 14) "known-images" "LAST-USED" <*> opt Nothing "unknown-images" "CREATED" <*> opt (Just 0) "dangling-images" "CREATED" <*> opt Nothing "stopped-containers" "CREATED" <*> opt Nothing "running-containers" "CREATED" where opt def' name mv = fmap Just (option auto (long name <> metavar (mv ++ "-DAYS-AGO") <> help ("Remove " ++ toDescr name ++ " " ++ map toLower (toDescr mv) ++ " N days ago" ++ case def' of Just n -> " (default " ++ show n ++ ")" Nothing -> ""))) <|> flag' Nothing (long ("no-" ++ name) <> help ("Do not remove " ++ toDescr name ++ case def' of Just _ -> "" Nothing -> " (default)")) <|> pure def' toDescr = map (\c -> if c == '-' then ' ' else c) stack-1.9.3.1/src/Stack/Options/DotParser.hs0000644000000000000000000000610213455617610016713 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude #-} {-# LANGUAGE OverloadedStrings #-} module Stack.Options.DotParser where import Data.Char (isSpace) import Data.List.Split (splitOn) import qualified Data.Set as Set import qualified Data.Text as T import Options.Applicative import Options.Applicative.Builder.Extra import Stack.Dot import Stack.Options.BuildParser import Stack.Prelude -- | Parser for arguments to `stack dot` dotOptsParser :: Bool -> Parser DotOpts dotOptsParser externalDefault = DotOpts <$> includeExternal <*> includeBase <*> depthLimit <*> fmap (maybe Set.empty Set.fromList . fmap splitNames) prunedPkgs <*> targetsParser <*> flagsParser <*> testTargets <*> benchTargets where includeExternal = boolFlags externalDefault "external" "inclusion of external dependencies" idm includeBase = boolFlags True "include-base" "inclusion of dependencies on base" idm depthLimit = optional (option auto (long "depth" <> metavar "DEPTH" <> help ("Limit the depth of dependency resolution " <> "(Default: No limit)"))) prunedPkgs = optional (strOption (long "prune" <> metavar "PACKAGES" <> help ("Prune each package name " <> "from the comma separated list " <> "of package names PACKAGES"))) testTargets = switch (long "test" <> help "Consider dependencies of test components") benchTargets = switch (long "bench" <> help "Consider dependencies of benchmark components") splitNames :: String -> [String] splitNames = map (takeWhile (not . isSpace) . dropWhile isSpace) . splitOn "," -- | Parser for arguments to `stack list-dependencies`. listDepsOptsParser :: Parser ListDepsOpts listDepsOptsParser = ListDepsOpts <$> dotOptsParser True -- Default for --external is True. <*> fmap escapeSep (textOption (long "separator" <> metavar "SEP" <> help ("Separator between package name " <> "and package version.") <> value " " <> showDefault)) <*> boolFlags False "license" "printing of dependency licenses instead of versions" idm where escapeSep sep = T.replace "\\t" "\t" (T.replace "\\n" "\n" sep) stack-1.9.3.1/src/Stack/Options/ExecParser.hs0000644000000000000000000000600613455617610017054 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude #-} module Stack.Options.ExecParser where import Options.Applicative import Options.Applicative.Builder.Extra import Options.Applicative.Args import Stack.Options.Completion import Stack.Prelude import Stack.Types.Config -- | Parser for exec command execOptsParser :: Maybe SpecialExecCmd -> Parser ExecOpts execOptsParser mcmd = ExecOpts <$> maybe eoCmdParser pure mcmd <*> eoArgsParser <*> execOptsExtraParser where eoCmdParser = ExecCmd <$> strArgument (metavar "CMD" <> completer projectExeCompleter) eoArgsParser = many (strArgument (metavar txt)) where txt = case mcmd of Nothing -> normalTxt Just ExecCmd{} -> normalTxt Just ExecRun -> "-- ARGS (e.g. stack run -- file.txt)" Just ExecGhc -> "-- ARGS (e.g. stack runghc -- X.hs -o x)" Just ExecRunGhc -> "-- ARGS (e.g. stack runghc -- X.hs)" normalTxt = "-- ARGS (e.g. stack exec -- ghc-pkg describe base)" evalOptsParser :: String -- ^ metavar -> Parser EvalOpts evalOptsParser meta = EvalOpts <$> eoArgsParser <*> execOptsExtraParser where eoArgsParser :: Parser String eoArgsParser = strArgument (metavar meta) -- | Parser for extra options to exec command execOptsExtraParser :: Parser ExecOptsExtra execOptsExtraParser = eoPlainParser <|> ExecOptsEmbellished <$> eoEnvSettingsParser <*> eoPackagesParser <*> eoRtsOptionsParser <*> eoCwdParser where eoEnvSettingsParser :: Parser EnvSettings eoEnvSettingsParser = EnvSettings <$> pure True <*> boolFlags True "ghc-package-path" "setting the GHC_PACKAGE_PATH variable for the subprocess" idm <*> boolFlags True "stack-exe" "setting the STACK_EXE environment variable to the path for the stack executable" idm <*> pure False <*> pure True eoPackagesParser :: Parser [String] eoPackagesParser = many (strOption (long "package" <> help "Additional packages that must be installed")) eoRtsOptionsParser :: Parser [String] eoRtsOptionsParser = concat <$> many (argsOption ( long "rts-options" <> help "Explicit RTS options to pass to application" <> metavar "RTSFLAG")) eoPlainParser :: Parser ExecOptsExtra eoPlainParser = flag' ExecOptsPlain (long "plain" <> help "Use an unmodified environment (only useful with Docker)") eoCwdParser :: Parser (Maybe FilePath) eoCwdParser = optional (strOption (long "cwd" <> help "Sets the working directory before executing" <> metavar "DIR" <> completer dirCompleter) ) stack-1.9.3.1/src/Stack/Options/GhcBuildParser.hs0000644000000000000000000000152613312026775017651 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude #-} module Stack.Options.GhcBuildParser where import Options.Applicative import Options.Applicative.Types import Stack.Options.Utils import Stack.Prelude import Stack.Types.CompilerBuild -- | GHC build parser ghcBuildParser :: Bool -> Parser CompilerBuild ghcBuildParser hide = option readGHCBuild (long "ghc-build" <> metavar "BUILD" <> completeWith ["standard", "gmp4", "nopie", "tinfo6", "tinfo6-nopie", "ncurses6", "integersimple"] <> help "Specialized GHC build, e.g. 'gmp4' or 'standard' (usually auto-detected)" <> hideMods hide ) where readGHCBuild = do s <- readerAsk case parseCompilerBuild s of Left e -> readerError (show e) Right v -> return v stack-1.9.3.1/src/Stack/Options/GhciParser.hs0000644000000000000000000000611013455617610017036 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude #-} module Stack.Options.GhciParser where import Options.Applicative import Options.Applicative.Args import Options.Applicative.Builder.Extra import Stack.Config (packagesParser) import Stack.Ghci (GhciOpts (..)) import Stack.Options.BuildParser (flagsParser) import Stack.Options.Completion import Stack.Prelude import Stack.Types.Version -- | Parser for GHCI options ghciOptsParser :: Parser GhciOpts ghciOptsParser = GhciOpts <$> many (textArgument (metavar "TARGET/FILE" <> completer (targetCompleter <> fileExtCompleter [".hs", ".lhs"]) <> help ("If none specified, use all local packages. " <> "See https://docs.haskellstack.org/en/v" <> versionString stackMinorVersion <> "/build_command/#target-syntax for details. " <> "If a path to a .hs or .lhs file is specified, it will be loaded."))) <*> fmap concat (many (argsOption (long "ghci-options" <> metavar "OPTIONS" <> completer ghcOptsCompleter <> help "Additional options passed to GHCi"))) <*> many (textOption (long "ghc-options" <> metavar "OPTIONS" <> completer ghcOptsCompleter <> help "Additional options passed to both GHC and GHCi")) <*> flagsParser <*> optional (strOption (long "with-ghc" <> metavar "GHC" <> help "Use this GHC to run GHCi")) <*> (not <$> boolFlags True "load" "load modules on start-up" idm) <*> packagesParser <*> optional (textOption (long "main-is" <> metavar "TARGET" <> completer targetCompleter <> help "Specify which target should contain the main \ \module to load, such as for an executable for \ \test suite or benchmark.")) <*> switch (long "load-local-deps" <> help "Load all local dependencies of your targets") -- TODO: deprecate this? probably useless. <*> switch (long "skip-intermediate-deps" <> help "Skip loading intermediate target dependencies" <> internal) <*> optional (boolFlagsNoDefault "package-hiding" "package hiding" idm) <*> switch (long "no-build" <> help "Don't build before launching GHCi" <> internal) <*> switch (long "only-main" <> help "Only load and import the main module. If no main module, no modules will be loaded.") stack-1.9.3.1/src/Stack/Options/GhcVariantParser.hs0000644000000000000000000000140313312026775020210 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude #-} module Stack.Options.GhcVariantParser where import Options.Applicative import Options.Applicative.Types (readerAsk) import Stack.Prelude import Stack.Options.Utils import Stack.Types.Config -- | GHC variant parser ghcVariantParser :: Bool -> Parser GHCVariant ghcVariantParser hide = option readGHCVariant (long "ghc-variant" <> metavar "VARIANT" <> help "Specialized GHC variant, e.g. integersimple (incompatible with --system-ghc)" <> hideMods hide ) where readGHCVariant = do s <- readerAsk case parseGHCVariant s of Left e -> readerError (show e) Right v -> return v stack-1.9.3.1/src/Stack/Options/GlobalParser.hs0000644000000000000000000001033213455617610017365 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude #-} {-# LANGUAGE RecordWildCards #-} module Stack.Options.GlobalParser where import Options.Applicative import Options.Applicative.Builder.Extra import qualified Stack.Docker as Docker import Stack.Init import Stack.Prelude import Stack.Options.ConfigParser import Stack.Options.LogLevelParser import Stack.Options.ResolverParser import Stack.Options.Utils import Stack.Types.Config import Stack.Types.Docker import Stack.Types.Runner -- | Parser for global command-line options. globalOptsParser :: FilePath -> GlobalOptsContext -> Maybe LogLevel -> Parser GlobalOptsMonoid globalOptsParser currentDir kind defLogLevel = GlobalOptsMonoid <$> optionalFirst (strOption (long Docker.reExecArgName <> hidden <> internal)) <*> optionalFirst (option auto (long dockerEntrypointArgName <> hidden <> internal)) <*> (First <$> logLevelOptsParser hide0 defLogLevel) <*> firstBoolFlags "time-in-log" "inclusion of timings in logs, for the purposes of using diff with logs" hide <*> configOptsParser currentDir kind <*> optionalFirst (abstractResolverOptsParser hide0) <*> optionalFirst (compilerOptsParser hide0) <*> firstBoolFlags "terminal" "overriding terminal detection in the case of running in a false terminal" hide <*> optionalFirst (option readColorWhen (long "color" <> metavar "WHEN" <> completeWith ["always", "never", "auto"] <> help "Specify when to use color in output; WHEN is 'always', 'never', \ \or 'auto'. On Windows versions before Windows 10, for terminals \ \that do not support color codes, the default is 'never'; color \ \may work on terminals that support color codes" <> hide)) <*> optionalFirst (option auto (long "terminal-width" <> metavar "INT" <> help "Specify the width of the terminal, used for pretty-print messages" <> hide)) <*> optionalFirst (strOption (long "stack-yaml" <> metavar "STACK-YAML" <> completer (fileExtCompleter [".yaml"]) <> help ("Override project stack.yaml file " <> "(overrides any STACK_YAML environment variable)") <> hide)) where hide = hideMods hide0 hide0 = kind /= OuterGlobalOpts -- | Create GlobalOpts from GlobalOptsMonoid. globalOptsFromMonoid :: Bool -> ColorWhen -> GlobalOptsMonoid -> GlobalOpts globalOptsFromMonoid defaultTerminal defaultColorWhen GlobalOptsMonoid{..} = GlobalOpts { globalReExecVersion = getFirst globalMonoidReExecVersion , globalDockerEntrypoint = getFirst globalMonoidDockerEntrypoint , globalLogLevel = fromFirst defaultLogLevel globalMonoidLogLevel , globalTimeInLog = fromFirst True globalMonoidTimeInLog , globalConfigMonoid = globalMonoidConfigMonoid , globalResolver = getFirst globalMonoidResolver , globalCompiler = getFirst globalMonoidCompiler , globalTerminal = fromFirst defaultTerminal globalMonoidTerminal , globalColorWhen = fromFirst defaultColorWhen globalMonoidColorWhen , globalTermWidth = getFirst globalMonoidTermWidth , globalStackYaml = maybe SYLDefault SYLOverride $ getFirst globalMonoidStackYaml } initOptsParser :: Parser InitOpts initOptsParser = InitOpts <$> searchDirs <*> solver <*> omitPackages <*> overwrite <*> fmap not ignoreSubDirs where searchDirs = many (textArgument (metavar "DIR" <> completer dirCompleter <> help "Directories to include, default is current directory.")) ignoreSubDirs = switch (long "ignore-subdirs" <> help "Do not search for .cabal files in sub directories") overwrite = switch (long "force" <> help "Force overwriting an existing stack.yaml") omitPackages = switch (long "omit-packages" <> help "Exclude conflicting or incompatible user packages") solver = switch (long "solver" <> help "Use a dependency solver to determine extra dependencies") stack-1.9.3.1/src/Stack/Options/HaddockParser.hs0000644000000000000000000000140313312026775017517 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude #-} module Stack.Options.HaddockParser where import Options.Applicative import Options.Applicative.Args import Stack.Options.Utils import Stack.Prelude import Stack.Types.Config -- | Parser for haddock arguments. haddockOptsParser :: Bool -> Parser HaddockOptsMonoid haddockOptsParser hide0 = HaddockOptsMonoid <$> fmap (fromMaybe []) (optional (argsOption (long "haddock-arguments" <> metavar "HADDOCK_ARGS" <> help "Arguments passed to the haddock program" <> hide))) where hide = hideMods hide0 stack-1.9.3.1/src/Stack/Options/HpcReportParser.hs0000644000000000000000000000321713312026775020075 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude #-} module Stack.Options.HpcReportParser where import qualified Data.Text as T import Options.Applicative import Options.Applicative.Builder.Extra import Options.Applicative.Types (readerAsk) import Stack.Coverage (HpcReportOpts (..)) import Stack.Options.Completion (targetCompleter) import Stack.Prelude import Stack.Types.Config -- | Parser for @stack hpc report@. hpcReportOptsParser :: Parser HpcReportOpts hpcReportOptsParser = HpcReportOpts <$> many (textArgument $ metavar "TARGET_OR_TIX" <> completer (targetCompleter <> fileExtCompleter [".tix"])) <*> switch (long "all" <> help "Use results from all packages and components involved in previous --coverage run") <*> optional (strOption (long "destdir" <> metavar "DIR" <> completer dirCompleter <> help "Output directory for HTML report")) <*> switch (long "open" <> help "Open the report in the browser") pvpBoundsOption :: Parser PvpBounds pvpBoundsOption = option readPvpBounds (long "pvp-bounds" <> metavar "PVP-BOUNDS" <> completeWith ["none", "lower", "upper", "both"] <> help "How PVP version bounds should be added to .cabal file: none, lower, upper, both") where readPvpBounds = do s <- readerAsk case parsePvpBounds $ T.pack s of Left e -> readerError e Right v -> return v stack-1.9.3.1/src/Stack/Options/LogLevelParser.hs0000644000000000000000000000306613312026775017702 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude #-} {-# LANGUAGE OverloadedStrings #-} module Stack.Options.LogLevelParser where import qualified Data.Text as T import Options.Applicative import Stack.Options.Utils import Stack.Prelude -- | Parser for a logging level. logLevelOptsParser :: Bool -> Maybe LogLevel -> Parser (Maybe LogLevel) logLevelOptsParser hide defLogLevel = fmap (Just . parse) (strOption (long "verbosity" <> metavar "VERBOSITY" <> completeWith ["silent", "error", "warn", "info", "debug"] <> help "Verbosity: silent, error, warn, info, debug" <> hideMods hide)) <|> flag' (Just verboseLevel) (short 'v' <> long "verbose" <> help ("Enable verbose mode: verbosity level \"" <> showLevel verboseLevel <> "\"") <> hideMods hide) <|> flag' (Just silentLevel) (long "silent" <> help ("Enable silent mode: verbosity level \"" <> showLevel silentLevel <> "\"") <> hideMods hide) <|> pure defLogLevel where verboseLevel = LevelDebug silentLevel = LevelOther "silent" showLevel l = case l of LevelDebug -> "debug" LevelInfo -> "info" LevelWarn -> "warn" LevelError -> "error" LevelOther x -> T.unpack x parse s = case s of "debug" -> LevelDebug "info" -> LevelInfo "warn" -> LevelWarn "error" -> LevelError _ -> LevelOther (T.pack s) stack-1.9.3.1/src/Stack/Options/NewParser.hs0000644000000000000000000000274013344044236016715 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude #-} module Stack.Options.NewParser where import qualified Data.Map.Strict as M import Options.Applicative import Stack.Init import Stack.New import Stack.Options.GlobalParser import Stack.Prelude import Stack.Types.PackageName import Stack.Types.TemplateName -- | Parser for @stack new@. newOptsParser :: Parser (NewOpts,InitOpts) newOptsParser = (,) <$> newOpts <*> initOptsParser where newOpts = NewOpts <$> packageNameArgument (metavar "PACKAGE_NAME" <> help "A valid package name.") <*> switch (long "bare" <> help "Do not create a subdirectory for the project") <*> optional (templateNameArgument (metavar "TEMPLATE_NAME" <> help "Name of a template - can take the form\ \ [[service:]username/]template with optional service name\ \ (github, gitlab, or bitbucket) \ \ and username for the service; or, a local filename such as\ \ foo.hsfiles or ~/foo; or, a full URL such as\ \ https://example.com/foo.hsfiles.")) <*> fmap M.fromList (many (templateParamArgument (short 'p' <> long "param" <> metavar "KEY:VALUE" <> help "Parameter for the template in the format key:value"))) stack-1.9.3.1/src/Stack/Options/NixParser.hs0000644000000000000000000000422413455617610016726 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude #-} module Stack.Options.NixParser where import qualified Data.Text as T import Options.Applicative import Options.Applicative.Args import Options.Applicative.Builder.Extra import Stack.Nix import Stack.Options.Utils import Stack.Prelude import Stack.Types.Nix nixOptsParser :: Bool -> Parser NixOptsMonoid nixOptsParser hide0 = overrideActivation <$> (NixOptsMonoid <$> firstBoolFlags nixCmdName "use of a Nix-shell. Implies 'system-ghc: true'" hide <*> firstBoolFlags "nix-pure" "use of a pure Nix-shell. Implies '--nix' and 'system-ghc: true'" hide <*> optionalFirst (textArgsOption (long "nix-packages" <> metavar "NAMES" <> help "List of packages that should be available in the nix-shell (space separated)" <> hide)) <*> optionalFirst (option str (long "nix-shell-file" <> metavar "FILE" <> completer (fileExtCompleter [".nix"]) <> help "Nix file to be used to launch a nix-shell (for regular Nix users)" <> hide)) <*> optionalFirst (textArgsOption (long "nix-shell-options" <> metavar "OPTIONS" <> help "Additional options passed to nix-shell" <> hide)) <*> optionalFirst (textArgsOption (long "nix-path" <> metavar "PATH_OPTIONS" <> help "Additional options to override NIX_PATH parts (notably 'nixpkgs')" <> hide)) <*> firstBoolFlags "nix-add-gc-roots" "addition of packages to the nix GC roots so nix-collect-garbage doesn't remove them" hide ) where hide = hideMods hide0 overrideActivation m = if fromFirst False (nixMonoidPureShell m) then m { nixMonoidEnable = (First . Just . fromFirst True) (nixMonoidEnable m) } else m textArgsOption = fmap (map T.pack) . argsOption stack-1.9.3.1/src/Stack/Options/PackageParser.hs0000644000000000000000000000236313455617610017525 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude #-} module Stack.Options.PackageParser where import qualified Data.Map as Map import Options.Applicative import Options.Applicative.Types (readerAsk) import Stack.Prelude import Stack.Types.FlagName import Stack.Types.PackageName -- | Parser for package:[-]flag readFlag :: ReadM (Map (Maybe PackageName) (Map FlagName Bool)) readFlag = do s <- readerAsk case break (== ':') s of (pn, ':':mflag) -> do pn' <- case parsePackageNameFromString pn of Nothing | pn == "*" -> return Nothing | otherwise -> readerError $ "Invalid package name: " ++ pn Just x -> return $ Just x let (b, flagS) = case mflag of '-':x -> (False, x) _ -> (True, mflag) flagN <- case parseFlagNameFromString flagS of Nothing -> readerError $ "Invalid flag name: " ++ flagS Just x -> return x return $ Map.singleton pn' $ Map.singleton flagN b _ -> readerError "Must have a colon" stack-1.9.3.1/src/Stack/Options/ResolverParser.hs0000644000000000000000000000224713455617610017774 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude #-} {-# LANGUAGE DataKinds #-} module Stack.Options.ResolverParser where import qualified Data.Text as T import Options.Applicative import Options.Applicative.Types (readerAsk) import Stack.Options.Utils import Stack.Prelude import Stack.Types.Compiler import Stack.Types.Resolver -- | Parser for the resolver abstractResolverOptsParser :: Bool -> Parser AbstractResolver abstractResolverOptsParser hide = option readAbstractResolver (long "resolver" <> metavar "RESOLVER" <> help "Override resolver in project file" <> hideMods hide) compilerOptsParser :: Bool -> Parser (CompilerVersion 'CVWanted) compilerOptsParser hide = option readCompilerVersion (long "compiler" <> metavar "COMPILER" <> help "Use the specified compiler" <> hideMods hide) readCompilerVersion :: ReadM (CompilerVersion 'CVWanted) readCompilerVersion = do s <- readerAsk case parseCompilerVersion (T.pack s) of Nothing -> readerError $ "Failed to parse compiler: " ++ s Just x -> return x stack-1.9.3.1/src/Stack/Options/ScriptParser.hs0000644000000000000000000000253213455617610017434 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude #-} module Stack.Options.ScriptParser where import Options.Applicative import Options.Applicative.Builder.Extra import Stack.Options.Completion import Stack.Prelude data ScriptOpts = ScriptOpts { soPackages :: ![String] , soFile :: !FilePath , soArgs :: ![String] , soCompile :: !ScriptExecute , soGhcOptions :: ![String] } deriving Show data ScriptExecute = SEInterpret | SECompile | SEOptimize deriving Show scriptOptsParser :: Parser ScriptOpts scriptOptsParser = ScriptOpts <$> many (strOption (long "package" <> help "Additional packages that must be installed")) <*> strArgument (metavar "FILE" <> completer (fileExtCompleter [".hs", ".lhs"])) <*> many (strArgument (metavar "-- ARGS (e.g. stack script X.hs -- args to program)")) <*> (flag' SECompile ( long "compile" <> help "Compile the script without optimization and run the executable" ) <|> flag' SEOptimize ( long "optimize" <> help "Compile the script with optimization and run the executable" ) <|> pure SEInterpret) <*> many (strOption (long "ghc-options" <> metavar "OPTIONS" <> completer ghcOptsCompleter <> help "Additional options passed to GHC")) stack-1.9.3.1/src/Stack/Options/SDistParser.hs0000644000000000000000000000244613455617610017222 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude #-} module Stack.Options.SDistParser where import Options.Applicative import Options.Applicative.Builder.Extra import Stack.Prelude import Stack.SDist import Stack.Options.HpcReportParser (pvpBoundsOption) -- | Parser for arguments to `stack sdist` and `stack upload` sdistOptsParser :: Bool -- ^ Whether to sign by default `stack upload` does, `stack sdist` doesn't -> Parser SDistOpts sdistOptsParser signDefault = SDistOpts <$> many (strArgument $ metavar "DIR" <> completer dirCompleter) <*> optional pvpBoundsOption <*> ignoreCheckSwitch <*> (if signDefault then not <$> switch (long "no-signature" <> help "Do not sign & upload signatures") else switch (long "sign" <> help "Sign & upload signatures")) <*> strOption (long "sig-server" <> metavar "URL" <> showDefault <> value "https://sig.commercialhaskell.org" <> help "URL") <*> buildPackageOption <*> optional (strOption (long "tar-dir" <> help "If specified, copy all the tar to this dir")) where ignoreCheckSwitch = switch (long "ignore-check" <> help "Do not check package for common mistakes") buildPackageOption = boolFlags False "test-tarball" "building of the resulting tarball" idm stack-1.9.3.1/src/Stack/Options/SolverParser.hs0000644000000000000000000000060713455617610017443 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude #-} module Stack.Options.SolverParser where import Options.Applicative import Options.Applicative.Builder.Extra import Stack.Prelude -- | Parser for @solverCmd@ solverOptsParser :: Parser Bool solverOptsParser = boolFlags False "update-config" "Automatically update stack.yaml with the solver's recommendations" idm stack-1.9.3.1/src/Stack/Options/TestParser.hs0000644000000000000000000000252313455617610017107 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude #-} module Stack.Options.TestParser where import Options.Applicative import Options.Applicative.Args import Options.Applicative.Builder.Extra import Stack.Options.Utils import Stack.Prelude import Stack.Types.Config -- | Parser for test arguments. -- FIXME hide args testOptsParser :: Bool -> Parser TestOptsMonoid testOptsParser hide0 = TestOptsMonoid <$> firstBoolFlags "rerun-tests" "running already successful tests" hide <*> fmap (fromMaybe []) (optional (argsOption (long "test-arguments" <> long "ta" <> metavar "TEST_ARGS" <> help "Arguments passed in to the test suite program" <> hide))) <*> optionalFirst (flag' True (long "coverage" <> help "Generate a code coverage report" <> hide)) <*> optionalFirst (flag' True (long "no-run-tests" <> help "Disable running of tests. (Tests will still be built.)" <> hide)) where hide = hideMods hide0 stack-1.9.3.1/src/Stack/Options/Utils.hs0000644000000000000000000000152213312026775016107 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude #-} module Stack.Options.Utils where import Options.Applicative import Stack.Prelude -- | If argument is True, hides the option from usage and help hideMods :: Bool -> Mod f a hideMods hide = if hide then internal <> hidden else idm -- | Allows adjust global options depending on their context -- Note: This was being used to remove ambibuity between the local and global -- implementation of stack init --resolver option. Now that stack init has no -- local --resolver this is not being used anymore but the code is kept for any -- similar future use cases. data GlobalOptsContext = OuterGlobalOpts -- ^ Global options before subcommand name | OtherCmdGlobalOpts -- ^ Global options following any other subcommand | BuildCmdGlobalOpts | GhciCmdGlobalOpts deriving (Show, Eq) stack-1.9.3.1/src/Stack/Package.hs0000644000000000000000000017545013455617610014725 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude #-} {-# LANGUAGE LambdaCase #-} {-# LANGUAGE TupleSections #-} {-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE FlexibleContexts #-} {-# LANGUAGE DataKinds #-} {-# LANGUAGE DeriveDataTypeable #-} {-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE RankNTypes #-} {-# LANGUAGE TemplateHaskell #-} {-# LANGUAGE ViewPatterns #-} {-# LANGUAGE RecordWildCards #-} -- | Dealing with Cabal. module Stack.Package (readPackageDir ,readPackageUnresolvedDir ,readPackageUnresolvedIndex ,readPackageDescriptionDir ,readDotBuildinfo ,resolvePackage ,packageFromPackageDescription ,Package(..) ,PackageDescriptionPair(..) ,GetPackageFiles(..) ,GetPackageOpts(..) ,PackageConfig(..) ,buildLogPath ,PackageException (..) ,resolvePackageDescription ,packageDependencies ,cabalFilePackageId ,gpdPackageIdentifier ,gpdPackageName ,gpdVersion) where import qualified Data.ByteString as BS import qualified Data.ByteString.Lazy.Char8 as CL8 import Data.List (isPrefixOf, unzip) import Data.Maybe (maybe) import qualified Data.Map.Strict as M import qualified Data.Set as S import qualified Data.Text as T import qualified Data.Text.Lazy as TL import qualified Data.Text.Lazy.Encoding as TLE import Distribution.Compiler import Distribution.ModuleName (ModuleName) import qualified Distribution.ModuleName as Cabal import qualified Distribution.Package as D import Distribution.Package hiding (Package,PackageName,packageName,packageVersion,PackageIdentifier) import qualified Distribution.PackageDescription as D import Distribution.PackageDescription hiding (FlagName) import Distribution.PackageDescription.Parsec import qualified Distribution.PackageDescription.Parsec as D import Distribution.Parsec.Common (PWarning (..), showPos) import Distribution.Simple.Glob (matchDirFileGlob) import Distribution.System (OS (..), Arch, Platform (..)) import qualified Distribution.Text as D import qualified Distribution.Types.CondTree as Cabal import qualified Distribution.Types.ExeDependency as Cabal import Distribution.Types.ForeignLib import qualified Distribution.Types.LegacyExeDependency as Cabal import Distribution.Types.MungedPackageName import qualified Distribution.Types.UnqualComponentName as Cabal import qualified Distribution.Types.Version as Cabal import qualified Distribution.Verbosity as D import Lens.Micro (lens) import qualified Hpack import qualified Hpack.Config as Hpack import Path as FL import Path.Extra import Path.Find import Path.IO hiding (findFiles) import Stack.Build.Installed import Stack.Constants import Stack.Constants.Config import Stack.Fetch (loadFromIndex) import Stack.PackageIndex (HasCabalLoader (..)) import Stack.Prelude hiding (Display (..)) import Stack.PrettyPrint import Stack.Types.Build import Stack.Types.BuildPlan (ExeName (..)) import Stack.Types.Compiler import Stack.Types.Config import Stack.Types.FlagName import Stack.Types.GhcPkgId import Stack.Types.NamedComponent import Stack.Types.Package import Stack.Types.PackageIdentifier import Stack.Types.PackageName import Stack.Types.Runner import Stack.Types.Version import qualified System.Directory as D import System.FilePath (replaceExtension) import qualified System.FilePath as FilePath import System.IO.Error import RIO.Process data Ctx = Ctx { ctxFile :: !(Path Abs File) , ctxDistDir :: !(Path Abs Dir) , ctxEnvConfig :: !EnvConfig } instance HasPlatform Ctx instance HasGHCVariant Ctx instance HasLogFunc Ctx where logFuncL = configL.logFuncL instance HasRunner Ctx where runnerL = configL.runnerL instance HasConfig Ctx instance HasCabalLoader Ctx where cabalLoaderL = configL.cabalLoaderL instance HasProcessContext Ctx where processContextL = configL.processContextL instance HasBuildConfig Ctx instance HasEnvConfig Ctx where envConfigL = lens ctxEnvConfig (\x y -> x { ctxEnvConfig = y }) -- | A helper function that performs the basic character encoding -- necessary. rawParseGPD :: MonadThrow m => Either PackageIdentifierRevision (Path Abs File) -> BS.ByteString -> m ([PWarning], GenericPackageDescription) rawParseGPD key bs = case eres of Left (mversion, errs) -> throwM $ PackageInvalidCabalFile key (fromCabalVersion <$> mversion) errs warnings Right gpkg -> return (warnings, gpkg) where (warnings, eres) = runParseResult $ parseGenericPackageDescription bs -- | Read the raw, unresolved package information from a file. readPackageUnresolvedDir :: forall env. HasConfig env => Path Abs Dir -- ^ directory holding the cabal file -> Bool -- ^ print warnings? -> RIO env (GenericPackageDescription, Path Abs File) readPackageUnresolvedDir dir printWarnings = do ref <- view $ runnerL.to runnerParsedCabalFiles (_, m) <- readIORef ref case M.lookup dir m of Just x -> return x Nothing -> do cabalfp <- findOrGenerateCabalFile dir bs <- liftIO $ BS.readFile $ toFilePath cabalfp (warnings, gpd) <- rawParseGPD (Right cabalfp) bs when printWarnings $ mapM_ (prettyWarnL . toPretty (toFilePath cabalfp)) warnings checkCabalFileName (gpdPackageName gpd) cabalfp let ret = (gpd, cabalfp) atomicModifyIORef' ref $ \(m1, m2) -> ((m1, M.insert dir ret m2), ret) where toPretty :: String -> PWarning -> [Doc AnsiAnn] toPretty src (PWarning _type pos msg) = [ flow "Cabal file warning in" , fromString src <> "@" , fromString (showPos pos) <> ":" , flow msg ] -- | Check if the given name in the @Package@ matches the name of the .cabal file checkCabalFileName :: MonadThrow m => PackageName -> Path Abs File -> m () checkCabalFileName name cabalfp = do -- Previously, we just use parsePackageNameFromFilePath. However, that can -- lead to confusing error messages. See: -- https://github.com/commercialhaskell/stack/issues/895 let expected = packageNameString name ++ ".cabal" when (expected /= toFilePath (filename cabalfp)) $ throwM $ MismatchedCabalName cabalfp name gpdPackageIdentifier :: GenericPackageDescription -> PackageIdentifier gpdPackageIdentifier = fromCabalPackageIdentifier . D.package . D.packageDescription gpdPackageName :: GenericPackageDescription -> PackageName gpdPackageName = packageIdentifierName . gpdPackageIdentifier gpdVersion :: GenericPackageDescription -> Version gpdVersion = packageIdentifierVersion . gpdPackageIdentifier -- | Read the 'GenericPackageDescription' from the given -- 'PackageIdentifierRevision'. readPackageUnresolvedIndex :: forall env. HasCabalLoader env => PackageIdentifierRevision -> RIO env GenericPackageDescription readPackageUnresolvedIndex pir@(PackageIdentifierRevision pi' _) = do ref <- view $ runnerL.to runnerParsedCabalFiles (m, _) <- readIORef ref case M.lookup pir m of Just gpd -> return gpd Nothing -> do bs <- loadFromIndex pir (_warnings, gpd) <- rawParseGPD (Left pir) bs let foundPI = fromCabalPackageIdentifier $ D.package $ D.packageDescription gpd unless (pi' == foundPI) $ throwM $ MismatchedCabalIdentifier pir foundPI atomicModifyIORef' ref $ \(m1, m2) -> ((M.insert pir gpd m1, m2), gpd) -- | Reads and exposes the package information readPackageDir :: forall env. HasConfig env => PackageConfig -> Path Abs Dir -> Bool -- ^ print warnings from cabal file parsing? -> RIO env (Package, Path Abs File) readPackageDir packageConfig dir printWarnings = first (resolvePackage packageConfig) <$> readPackageUnresolvedDir dir printWarnings -- | Get 'GenericPackageDescription' and 'PackageDescription' reading info -- from given directory. readPackageDescriptionDir :: forall env. HasConfig env => PackageConfig -> Path Abs Dir -> Bool -- ^ print warnings? -> RIO env (GenericPackageDescription, PackageDescriptionPair) readPackageDescriptionDir config pkgDir printWarnings = do (gdesc, _) <- readPackageUnresolvedDir pkgDir printWarnings return (gdesc, resolvePackageDescription config gdesc) -- | Read @.buildinfo@ ancillary files produced by some Setup.hs hooks. -- The file includes Cabal file syntax to be merged into the package description -- derived from the package's .cabal file. -- -- NOTE: not to be confused with BuildInfo, an Stack-internal datatype. readDotBuildinfo :: MonadIO m => Path Abs File -> m HookedBuildInfo readDotBuildinfo buildinfofp = liftIO $ readHookedBuildInfo D.silent (toFilePath buildinfofp) -- | Resolve a parsed cabal file into a 'Package', which contains all of -- the info needed for stack to build the 'Package' given the current -- configuration. resolvePackage :: PackageConfig -> GenericPackageDescription -> Package resolvePackage packageConfig gpkg = packageFromPackageDescription packageConfig (genPackageFlags gpkg) (resolvePackageDescription packageConfig gpkg) packageFromPackageDescription :: PackageConfig -> [D.Flag] -> PackageDescriptionPair -> Package packageFromPackageDescription packageConfig pkgFlags (PackageDescriptionPair pkgNoMod pkg) = Package { packageName = name , packageVersion = fromCabalVersion (pkgVersion pkgId) , packageLicense = licenseRaw pkg , packageDeps = deps , packageFiles = pkgFiles , packageUnknownTools = unknownTools , packageGhcOptions = packageConfigGhcOptions packageConfig , packageFlags = packageConfigFlags packageConfig , packageDefaultFlags = M.fromList [(fromCabalFlagName (flagName flag), flagDefault flag) | flag <- pkgFlags] , packageAllDeps = S.fromList (M.keys deps) , packageLibraries = let mlib = do lib <- library pkg guard $ buildable $ libBuildInfo lib Just lib in case mlib of Nothing -> NoLibraries Just _ -> HasLibraries foreignLibNames , packageInternalLibraries = subLibNames , packageTests = M.fromList [(T.pack (Cabal.unUnqualComponentName $ testName t), testInterface t) | t <- testSuites pkgNoMod , buildable (testBuildInfo t) ] , packageBenchmarks = S.fromList [T.pack (Cabal.unUnqualComponentName $ benchmarkName b) | b <- benchmarks pkgNoMod , buildable (benchmarkBuildInfo b) ] -- Same comment about buildable applies here too. , packageExes = S.fromList [T.pack (Cabal.unUnqualComponentName $ exeName biBuildInfo) | biBuildInfo <- executables pkg , buildable (buildInfo biBuildInfo)] -- This is an action used to collect info needed for "stack ghci". -- This info isn't usually needed, so computation of it is deferred. , packageOpts = GetPackageOpts $ \sourceMap installedMap omitPkgs addPkgs cabalfp -> do (componentsModules,componentFiles,_,_) <- getPackageFiles pkgFiles cabalfp let internals = S.toList $ internalLibComponents $ M.keysSet componentsModules excludedInternals <- mapM parsePackageName internals mungedInternals <- mapM (parsePackageName . toInternalPackageMungedName) internals componentsOpts <- generatePkgDescOpts sourceMap installedMap (excludedInternals ++ omitPkgs) (mungedInternals ++ addPkgs) cabalfp pkg componentFiles return (componentsModules,componentFiles,componentsOpts) , packageHasExposedModules = maybe False (not . null . exposedModules) (library pkg) , packageBuildType = buildType pkg , packageSetupDeps = msetupDeps } where extraLibNames = S.union subLibNames foreignLibNames subLibNames = S.fromList $ map (T.pack . Cabal.unUnqualComponentName) $ mapMaybe libName -- this is a design bug in the Cabal API: this should statically be known to exist $ filter (buildable . libBuildInfo) $ subLibraries pkg foreignLibNames = S.fromList $ map (T.pack . Cabal.unUnqualComponentName . foreignLibName) $ filter (buildable . foreignLibBuildInfo) $ foreignLibs pkg toInternalPackageMungedName = T.pack . unMungedPackageName . computeCompatPackageName (pkgName pkgId) . Just . Cabal.mkUnqualComponentName . T.unpack -- Gets all of the modules, files, build files, and data files that -- constitute the package. This is primarily used for dirtiness -- checking during build, as well as use by "stack ghci" pkgFiles = GetPackageFiles $ \cabalfp -> debugBracket ("getPackageFiles" <+> display cabalfp) $ do let pkgDir = parent cabalfp distDir <- distDirFromDir pkgDir env <- view envConfigL (componentModules,componentFiles,dataFiles',warnings) <- runRIO (Ctx cabalfp distDir env) (packageDescModulesAndFiles pkg) setupFiles <- if buildType pkg == Custom then do let setupHsPath = pkgDir $(mkRelFile "Setup.hs") setupLhsPath = pkgDir $(mkRelFile "Setup.lhs") setupHsExists <- doesFileExist setupHsPath if setupHsExists then return (S.singleton setupHsPath) else do setupLhsExists <- doesFileExist setupLhsPath if setupLhsExists then return (S.singleton setupLhsPath) else return S.empty else return S.empty buildFiles <- liftM (S.insert cabalfp . S.union setupFiles) $ do let hpackPath = pkgDir $(mkRelFile Hpack.packageConfig) hpackExists <- doesFileExist hpackPath return $ if hpackExists then S.singleton hpackPath else S.empty return (componentModules, componentFiles, buildFiles <> dataFiles', warnings) pkgId = package pkg name = fromCabalPackageName (pkgName pkgId) (unknownTools, knownTools) = packageDescTools pkg deps = M.filterWithKey (const . not . isMe) (M.unionsWith (<>) [ asLibrary <$> packageDependencies packageConfig pkg -- We include all custom-setup deps - if present - in the -- package deps themselves. Stack always works with the -- invariant that there will be a single installed package -- relating to a package name, and this applies at the setup -- dependency level as well. , asLibrary <$> fromMaybe M.empty msetupDeps , knownTools ]) msetupDeps = fmap (M.fromList . map (depName &&& depRange) . setupDepends) (setupBuildInfo pkg) asLibrary range = DepValue { dvVersionRange = range , dvType = AsLibrary } -- Is the package dependency mentioned here me: either the package -- name itself, or the name of one of the sub libraries isMe name' = name' == name || packageNameText name' `S.member` extraLibNames -- | Generate GHC options for the package's components, and a list of -- options which apply generally to the package, not one specific -- component. generatePkgDescOpts :: (HasEnvConfig env, MonadThrow m, MonadReader env m, MonadIO m) => SourceMap -> InstalledMap -> [PackageName] -- ^ Packages to omit from the "-package" / "-package-id" flags -> [PackageName] -- ^ Packages to add to the "-package" flags -> Path Abs File -> PackageDescription -> Map NamedComponent (Set DotCabalPath) -> m (Map NamedComponent BuildInfoOpts) generatePkgDescOpts sourceMap installedMap omitPkgs addPkgs cabalfp pkg componentPaths = do config <- view configL cabalVer <- view cabalVersionL distDir <- distDirFromDir cabalDir let generate namedComponent binfo = ( namedComponent , generateBuildInfoOpts BioInput { biSourceMap = sourceMap , biInstalledMap = installedMap , biCabalDir = cabalDir , biDistDir = distDir , biOmitPackages = omitPkgs , biAddPackages = addPkgs , biBuildInfo = binfo , biDotCabalPaths = fromMaybe mempty (M.lookup namedComponent componentPaths) , biConfigLibDirs = configExtraLibDirs config , biConfigIncludeDirs = configExtraIncludeDirs config , biComponentName = namedComponent , biCabalVersion = cabalVer } ) return ( M.fromList (concat [ maybe [] (return . generate CLib . libBuildInfo) (library pkg) , mapMaybe (\sublib -> do let maybeLib = CInternalLib . T.pack . Cabal.unUnqualComponentName <$> libName sublib flip generate (libBuildInfo sublib) <$> maybeLib ) (subLibraries pkg) , fmap (\exe -> generate (CExe (T.pack (Cabal.unUnqualComponentName (exeName exe)))) (buildInfo exe)) (executables pkg) , fmap (\bench -> generate (CBench (T.pack (Cabal.unUnqualComponentName (benchmarkName bench)))) (benchmarkBuildInfo bench)) (benchmarks pkg) , fmap (\test -> generate (CTest (T.pack (Cabal.unUnqualComponentName (testName test)))) (testBuildInfo test)) (testSuites pkg)])) where cabalDir = parent cabalfp -- | Input to 'generateBuildInfoOpts' data BioInput = BioInput { biSourceMap :: !SourceMap , biInstalledMap :: !InstalledMap , biCabalDir :: !(Path Abs Dir) , biDistDir :: !(Path Abs Dir) , biOmitPackages :: ![PackageName] , biAddPackages :: ![PackageName] , biBuildInfo :: !BuildInfo , biDotCabalPaths :: !(Set DotCabalPath) , biConfigLibDirs :: !(Set FilePath) , biConfigIncludeDirs :: !(Set FilePath) , biComponentName :: !NamedComponent , biCabalVersion :: !Version } -- | Generate GHC options for the target. Since Cabal also figures out -- these options, currently this is only used for invoking GHCI (via -- stack ghci). generateBuildInfoOpts :: BioInput -> BuildInfoOpts generateBuildInfoOpts BioInput {..} = BuildInfoOpts { bioOpts = ghcOpts ++ cppOptions biBuildInfo -- NOTE for future changes: Due to this use of nubOrd (and other uses -- downstream), these generated options must not rely on multiple -- argument sequences. For example, ["--main-is", "Foo.hs", "--main- -- is", "Bar.hs"] would potentially break due to the duplicate -- "--main-is" being removed. -- -- See https://github.com/commercialhaskell/stack/issues/1255 , bioOneWordOpts = nubOrd $ concat [extOpts, srcOpts, includeOpts, libOpts, fworks, cObjectFiles] , bioPackageFlags = deps , bioCabalMacros = componentAutogen $(mkRelFile "cabal_macros.h") } where cObjectFiles = mapMaybe (fmap toFilePath . makeObjectFilePathFromC biCabalDir biComponentName biDistDir) cfiles cfiles = mapMaybe dotCabalCFilePath (S.toList biDotCabalPaths) -- Generates: -package=base -package=base16-bytestring-0.1.1.6 ... deps = concat [ case M.lookup name biInstalledMap of Just (_, Stack.Types.Package.Library _ident ipid _) -> ["-package-id=" <> ghcPkgIdString ipid] _ -> ["-package=" <> packageNameString name <> maybe "" -- This empty case applies to e.g. base. ((("-" <>) . versionString) . piiVersion) (M.lookup name biSourceMap)] | name <- pkgs] pkgs = biAddPackages ++ [ name | Dependency cname _ <- targetBuildDepends biBuildInfo , let name = fromCabalPackageName cname , name `notElem` biOmitPackages] ghcOpts = concatMap snd . filter (isGhc . fst) $ options biBuildInfo where isGhc GHC = True isGhc _ = False extOpts = map (("-X" ++) . D.display) (usedExtensions biBuildInfo) srcOpts = map (("-i" <>) . toFilePathNoTrailingSep) (concat [ [ componentBuildDir biCabalVersion biComponentName biDistDir ] , [ biCabalDir | null (hsSourceDirs biBuildInfo) ] , mapMaybe toIncludeDir (hsSourceDirs biBuildInfo) , [ componentAutogen ] , maybeToList (packageAutogenDir biCabalVersion biDistDir) , [ componentOutputDir biComponentName biDistDir ] ]) ++ [ "-stubdir=" ++ toFilePathNoTrailingSep (buildDir biDistDir) ] componentAutogen = componentAutogenDir biCabalVersion biComponentName biDistDir toIncludeDir "." = Just biCabalDir toIncludeDir relDir = concatAndColapseAbsDir biCabalDir relDir includeOpts = map ("-I" <>) (configExtraIncludeDirs <> pkgIncludeOpts) configExtraIncludeDirs = S.toList biConfigIncludeDirs pkgIncludeOpts = [ toFilePathNoTrailingSep absDir | dir <- includeDirs biBuildInfo , absDir <- handleDir dir ] libOpts = map ("-l" <>) (extraLibs biBuildInfo) <> map ("-L" <>) (configExtraLibDirs <> pkgLibDirs) configExtraLibDirs = S.toList biConfigLibDirs pkgLibDirs = [ toFilePathNoTrailingSep absDir | dir <- extraLibDirs biBuildInfo , absDir <- handleDir dir ] handleDir dir = case (parseAbsDir dir, parseRelDir dir) of (Just ab, _ ) -> [ab] (_ , Just rel) -> [biCabalDir rel] (Nothing, Nothing ) -> [] fworks = map (\fwk -> "-framework=" <> fwk) (frameworks biBuildInfo) -- | Make the .o path from the .c file path for a component. Example: -- -- @ -- executable FOO -- c-sources: cbits/text_search.c -- @ -- -- Produces -- -- /build/FOO/FOO-tmp/cbits/text_search.o -- -- Example: -- -- λ> makeObjectFilePathFromC -- $(mkAbsDir "/Users/chris/Repos/hoogle") -- CLib -- $(mkAbsDir "/Users/chris/Repos/hoogle/.stack-work/Cabal-x.x.x/dist") -- $(mkAbsFile "/Users/chris/Repos/hoogle/cbits/text_search.c") -- Just "/Users/chris/Repos/hoogle/.stack-work/Cabal-x.x.x/dist/build/cbits/text_search.o" -- λ> makeObjectFilePathFromC -- $(mkAbsDir "/Users/chris/Repos/hoogle") -- (CExe "hoogle") -- $(mkAbsDir "/Users/chris/Repos/hoogle/.stack-work/Cabal-x.x.x/dist") -- $(mkAbsFile "/Users/chris/Repos/hoogle/cbits/text_search.c") -- Just "/Users/chris/Repos/hoogle/.stack-work/Cabal-x.x.x/dist/build/hoogle/hoogle-tmp/cbits/text_search.o" -- λ> makeObjectFilePathFromC :: MonadThrow m => Path Abs Dir -- ^ The cabal directory. -> NamedComponent -- ^ The name of the component. -> Path Abs Dir -- ^ Dist directory. -> Path Abs File -- ^ The path to the .c file. -> m (Path Abs File) -- ^ The path to the .o file for the component. makeObjectFilePathFromC cabalDir namedComponent distDir cFilePath = do relCFilePath <- stripProperPrefix cabalDir cFilePath relOFilePath <- parseRelFile (replaceExtension (toFilePath relCFilePath) "o") return (componentOutputDir namedComponent distDir relOFilePath) -- | Make the global autogen dir if Cabal version is new enough. packageAutogenDir :: Version -> Path Abs Dir -> Maybe (Path Abs Dir) packageAutogenDir cabalVer distDir | cabalVer < $(mkVersion "2.0") = Nothing | otherwise = Just $ buildDir distDir $(mkRelDir "global-autogen") -- | Make the autogen dir. componentAutogenDir :: Version -> NamedComponent -> Path Abs Dir -> Path Abs Dir componentAutogenDir cabalVer component distDir = componentBuildDir cabalVer component distDir $(mkRelDir "autogen") -- | See 'Distribution.Simple.LocalBuildInfo.componentBuildDir' componentBuildDir :: Version -> NamedComponent -> Path Abs Dir -> Path Abs Dir componentBuildDir cabalVer component distDir | cabalVer < $(mkVersion "2.0") = buildDir distDir | otherwise = case component of CLib -> buildDir distDir CInternalLib name -> buildDir distDir componentNameToDir name CExe name -> buildDir distDir componentNameToDir name CTest name -> buildDir distDir componentNameToDir name CBench name -> buildDir distDir componentNameToDir name -- | The directory where generated files are put like .o or .hs (from .x files). componentOutputDir :: NamedComponent -> Path Abs Dir -> Path Abs Dir componentOutputDir namedComponent distDir = case namedComponent of CLib -> buildDir distDir CInternalLib name -> makeTmp name CExe name -> makeTmp name CTest name -> makeTmp name CBench name -> makeTmp name where makeTmp name = buildDir distDir componentNameToDir (name <> "/" <> name <> "-tmp") -- | Make the build dir. Note that Cabal >= 2.0 uses the -- 'componentBuildDir' above for some things. buildDir :: Path Abs Dir -> Path Abs Dir buildDir distDir = distDir $(mkRelDir "build") -- NOTE: don't export this, only use it for valid paths based on -- component names. componentNameToDir :: Text -> Path Rel Dir componentNameToDir name = fromMaybe (error "Invariant violated: component names should always parse as directory names") (parseRelDir (T.unpack name)) -- | Get all dependencies of the package (buildable targets only). -- -- Note that for Cabal versions 1.22 and earlier, there is a bug where -- Cabal requires dependencies for non-buildable components to be -- present. We're going to use GHC version as a proxy for Cabal -- library version in this case for simplicity, so we'll check for GHC -- being 7.10 or earlier. This obviously makes our function a lot more -- fun to write... packageDependencies :: PackageConfig -> PackageDescription -> Map PackageName VersionRange packageDependencies pkgConfig pkg' = M.fromListWith intersectVersionRanges $ map (depName &&& depRange) $ concatMap targetBuildDepends (allBuildInfo' pkg) ++ maybe [] setupDepends (setupBuildInfo pkg) where pkg | getGhcVersion (packageConfigCompilerVersion pkgConfig) >= $(mkVersion "8.0") = pkg' -- Set all components to buildable. Only need to worry about -- library, exe, test, and bench, since others didn't exist in -- older Cabal versions | otherwise = pkg' { library = (\c -> c { libBuildInfo = go (libBuildInfo c) }) <$> library pkg' , executables = (\c -> c { buildInfo = go (buildInfo c) }) <$> executables pkg' , testSuites = if packageConfigEnableTests pkgConfig then (\c -> c { testBuildInfo = go (testBuildInfo c) }) <$> testSuites pkg' else testSuites pkg' , benchmarks = if packageConfigEnableBenchmarks pkgConfig then (\c -> c { benchmarkBuildInfo = go (benchmarkBuildInfo c) }) <$> benchmarks pkg' else benchmarks pkg' } go bi = bi { buildable = True } -- | Get all dependencies of the package (buildable targets only). -- -- This uses both the new 'buildToolDepends' and old 'buildTools' -- information. packageDescTools :: PackageDescription -> (Set ExeName, Map PackageName DepValue) packageDescTools pd = (S.fromList $ concat unknowns, M.fromListWith (<>) $ concat knowns) where (unknowns, knowns) = unzip $ map perBI $ allBuildInfo' pd perBI :: BuildInfo -> ([ExeName], [(PackageName, DepValue)]) perBI bi = (unknownTools, tools) where (unknownTools, knownTools) = partitionEithers $ map go1 (buildTools bi) tools = mapMaybe go2 (knownTools ++ buildToolDepends bi) -- This is similar to desugarBuildTool from Cabal, however it -- uses our own hard-coded map which drops tools shipped with -- GHC (like hsc2hs), and includes some tools from Stackage. go1 :: Cabal.LegacyExeDependency -> Either ExeName Cabal.ExeDependency go1 (Cabal.LegacyExeDependency name range) = case M.lookup name hardCodedMap of Just pkgName -> Right $ Cabal.ExeDependency pkgName (Cabal.mkUnqualComponentName name) range Nothing -> Left $ ExeName $ T.pack name go2 :: Cabal.ExeDependency -> Maybe (PackageName, DepValue) go2 (Cabal.ExeDependency pkg _name range) | pkg `S.member` preInstalledPackages = Nothing | otherwise = Just ( fromCabalPackageName pkg , DepValue { dvVersionRange = range , dvType = AsBuildTool } ) -- | A hard-coded map for tool dependencies hardCodedMap :: Map String D.PackageName hardCodedMap = M.fromList [ ("alex", Distribution.Package.mkPackageName "alex") , ("happy", Distribution.Package.mkPackageName "happy") , ("cpphs", Distribution.Package.mkPackageName "cpphs") , ("greencard", Distribution.Package.mkPackageName "greencard") , ("c2hs", Distribution.Package.mkPackageName "c2hs") , ("hscolour", Distribution.Package.mkPackageName "hscolour") , ("hspec-discover", Distribution.Package.mkPackageName "hspec-discover") , ("hsx2hs", Distribution.Package.mkPackageName "hsx2hs") , ("gtk2hsC2hs", Distribution.Package.mkPackageName "gtk2hs-buildtools") , ("gtk2hsHookGenerator", Distribution.Package.mkPackageName "gtk2hs-buildtools") , ("gtk2hsTypeGen", Distribution.Package.mkPackageName "gtk2hs-buildtools") ] -- | Executable-only packages which come pre-installed with GHC and do -- not need to be built. Without this exception, we would either end -- up unnecessarily rebuilding these packages, or failing because the -- packages do not appear in the Stackage snapshot. preInstalledPackages :: Set D.PackageName preInstalledPackages = S.fromList [ D.mkPackageName "hsc2hs" , D.mkPackageName "haddock" ] -- | Variant of 'allBuildInfo' from Cabal that, like versions before -- 2.2, only includes buildable components. allBuildInfo' :: PackageDescription -> [BuildInfo] allBuildInfo' pkg_descr = [ bi | lib <- allLibraries pkg_descr , let bi = libBuildInfo lib , buildable bi ] ++ [ bi | flib <- foreignLibs pkg_descr , let bi = foreignLibBuildInfo flib , buildable bi ] ++ [ bi | exe <- executables pkg_descr , let bi = buildInfo exe , buildable bi ] ++ [ bi | tst <- testSuites pkg_descr , let bi = testBuildInfo tst , buildable bi ] ++ [ bi | tst <- benchmarks pkg_descr , let bi = benchmarkBuildInfo tst , buildable bi ] -- | Get all files referenced by the package. packageDescModulesAndFiles :: PackageDescription -> RIO Ctx (Map NamedComponent (Map ModuleName (Path Abs File)), Map NamedComponent (Set DotCabalPath), Set (Path Abs File), [PackageWarning]) packageDescModulesAndFiles pkg = do (libraryMods,libDotCabalFiles,libWarnings) <- maybe (return (M.empty, M.empty, [])) (asModuleAndFileMap libComponent libraryFiles) (library pkg) (subLibrariesMods,subLibDotCabalFiles,subLibWarnings) <- liftM foldTuples (mapM (asModuleAndFileMap internalLibComponent libraryFiles) (subLibraries pkg)) (executableMods,exeDotCabalFiles,exeWarnings) <- liftM foldTuples (mapM (asModuleAndFileMap exeComponent executableFiles) (executables pkg)) (testMods,testDotCabalFiles,testWarnings) <- liftM foldTuples (mapM (asModuleAndFileMap testComponent testFiles) (testSuites pkg)) (benchModules,benchDotCabalPaths,benchWarnings) <- liftM foldTuples (mapM (asModuleAndFileMap benchComponent benchmarkFiles) (benchmarks pkg)) dfiles <- resolveGlobFiles (specVersion pkg) (extraSrcFiles pkg ++ map (dataDir pkg FilePath.) (dataFiles pkg)) let modules = libraryMods <> subLibrariesMods <> executableMods <> testMods <> benchModules files = libDotCabalFiles <> subLibDotCabalFiles <> exeDotCabalFiles <> testDotCabalFiles <> benchDotCabalPaths warnings = libWarnings <> subLibWarnings <> exeWarnings <> testWarnings <> benchWarnings return (modules, files, dfiles, warnings) where libComponent = const CLib internalLibComponent = CInternalLib . T.pack . maybe "" Cabal.unUnqualComponentName . libName exeComponent = CExe . T.pack . Cabal.unUnqualComponentName . exeName testComponent = CTest . T.pack . Cabal.unUnqualComponentName . testName benchComponent = CBench . T.pack . Cabal.unUnqualComponentName . benchmarkName asModuleAndFileMap label f lib = do (a,b,c) <- f (label lib) lib return (M.singleton (label lib) a, M.singleton (label lib) b, c) foldTuples = foldl' (<>) (M.empty, M.empty, []) -- | Resolve globbing of files (e.g. data files) to absolute paths. resolveGlobFiles :: Cabal.Version -- ^ cabal file version -> [String] -> RIO Ctx (Set (Path Abs File)) resolveGlobFiles cabalFileVersion = liftM (S.fromList . catMaybes . concat) . mapM resolve where resolve name = if '*' `elem` name then explode name else liftM return (resolveFileOrWarn name) explode name = do dir <- asks (parent . ctxFile) names <- matchDirFileGlob' (FL.toFilePath dir) name mapM resolveFileOrWarn names matchDirFileGlob' dir glob = catch (liftIO (matchDirFileGlob minBound cabalFileVersion dir glob)) (\(e :: IOException) -> if isUserError e then do prettyWarnL [ flow "Wildcard does not match any files:" , styleFile $ fromString glob , line <> flow "in directory:" , styleDir $ fromString dir ] return [] else throwIO e) -- | Get all files referenced by the benchmark. benchmarkFiles :: NamedComponent -> Benchmark -> RIO Ctx (Map ModuleName (Path Abs File), Set DotCabalPath, [PackageWarning]) benchmarkFiles component bench = do resolveComponentFiles component build names where names = bnames <> exposed exposed = case benchmarkInterface bench of BenchmarkExeV10 _ fp -> [DotCabalMain fp] BenchmarkUnsupported _ -> [] bnames = map DotCabalModule (otherModules build) build = benchmarkBuildInfo bench -- | Get all files referenced by the test. testFiles :: NamedComponent -> TestSuite -> RIO Ctx (Map ModuleName (Path Abs File), Set DotCabalPath, [PackageWarning]) testFiles component test = do resolveComponentFiles component build names where names = bnames <> exposed exposed = case testInterface test of TestSuiteExeV10 _ fp -> [DotCabalMain fp] TestSuiteLibV09 _ mn -> [DotCabalModule mn] TestSuiteUnsupported _ -> [] bnames = map DotCabalModule (otherModules build) build = testBuildInfo test -- | Get all files referenced by the executable. executableFiles :: NamedComponent -> Executable -> RIO Ctx (Map ModuleName (Path Abs File), Set DotCabalPath, [PackageWarning]) executableFiles component exe = do resolveComponentFiles component build names where build = buildInfo exe names = map DotCabalModule (otherModules build) ++ [DotCabalMain (modulePath exe)] -- | Get all files referenced by the library. libraryFiles :: NamedComponent -> Library -> RIO Ctx (Map ModuleName (Path Abs File), Set DotCabalPath, [PackageWarning]) libraryFiles component lib = do resolveComponentFiles component build names where build = libBuildInfo lib names = bnames ++ exposed exposed = map DotCabalModule (exposedModules lib) bnames = map DotCabalModule (otherModules build) -- | Get all files referenced by the component. resolveComponentFiles :: NamedComponent -> BuildInfo -> [DotCabalDescriptor] -> RIO Ctx (Map ModuleName (Path Abs File), Set DotCabalPath, [PackageWarning]) resolveComponentFiles component build names = do dirs <- mapMaybeM resolveDirOrWarn (hsSourceDirs build) dir <- asks (parent . ctxFile) (modules,files,warnings) <- resolveFilesAndDeps component (dirs ++ [dir]) names haskellModuleExts cfiles <- buildOtherSources build return (modules, files <> cfiles, warnings) -- | Get all C sources and extra source files in a build. buildOtherSources :: BuildInfo -> RIO Ctx (Set DotCabalPath) buildOtherSources build = do csources <- liftM (S.map DotCabalCFilePath . S.fromList) (mapMaybeM resolveFileOrWarn (cSources build)) jsources <- liftM (S.map DotCabalFilePath . S.fromList) (mapMaybeM resolveFileOrWarn (targetJsSources build)) return (csources <> jsources) -- | Get the target's JS sources. targetJsSources :: BuildInfo -> [FilePath] targetJsSources = jsSources -- | A pair of package descriptions: one which modified the buildable -- values of test suites and benchmarks depending on whether they are -- enabled, and one which does not. -- -- Fields are intentionally lazy, we may only need one or the other -- value. -- -- MSS 2017-08-29: The very presence of this data type is terribly -- ugly, it represents the fact that the Cabal 2.0 upgrade did _not_ -- go well. Specifically, we used to have a field to indicate whether -- a component was enabled in addition to buildable, but that's gone -- now, and this is an ugly proxy. We should at some point clean up -- the mess of Package, LocalPackage, etc, and probably pull in the -- definition of PackageDescription from Cabal with our additionally -- needed metadata. But this is a good enough hack for the -- moment. Odds are, you're reading this in the year 2024 and thinking -- "wtf?" data PackageDescriptionPair = PackageDescriptionPair { pdpOrigBuildable :: PackageDescription , pdpModifiedBuildable :: PackageDescription } -- | Evaluates the conditions of a 'GenericPackageDescription', yielding -- a resolved 'PackageDescription'. resolvePackageDescription :: PackageConfig -> GenericPackageDescription -> PackageDescriptionPair resolvePackageDescription packageConfig (GenericPackageDescription desc defaultFlags mlib subLibs foreignLibs' exes tests benches) = PackageDescriptionPair { pdpOrigBuildable = go False , pdpModifiedBuildable = go True } where go modBuildable = desc {library = fmap (resolveConditions rc updateLibDeps) mlib ,subLibraries = map (\(n, v) -> (resolveConditions rc updateLibDeps v){libName=Just n}) subLibs ,foreignLibs = map (\(n, v) -> (resolveConditions rc updateForeignLibDeps v){foreignLibName=n}) foreignLibs' ,executables = map (\(n, v) -> (resolveConditions rc updateExeDeps v){exeName=n}) exes ,testSuites = map (\(n,v) -> (resolveConditions rc (updateTestDeps modBuildable) v){testName=n}) tests ,benchmarks = map (\(n,v) -> (resolveConditions rc (updateBenchmarkDeps modBuildable) v){benchmarkName=n}) benches} flags = M.union (packageConfigFlags packageConfig) (flagMap defaultFlags) rc = mkResolveConditions (packageConfigCompilerVersion packageConfig) (packageConfigPlatform packageConfig) flags updateLibDeps lib deps = lib {libBuildInfo = (libBuildInfo lib) {targetBuildDepends = deps}} updateForeignLibDeps lib deps = lib {foreignLibBuildInfo = (foreignLibBuildInfo lib) {targetBuildDepends = deps}} updateExeDeps exe deps = exe {buildInfo = (buildInfo exe) {targetBuildDepends = deps}} -- Note that, prior to moving to Cabal 2.0, we would set -- testEnabled/benchmarkEnabled here. These fields no longer -- exist, so we modify buildable instead here. The only -- wrinkle in the Cabal 2.0 story is -- https://github.com/haskell/cabal/issues/1725, where older -- versions of Cabal (which may be used for actually building -- code) don't properly exclude build-depends for -- non-buildable components. Testing indicates that everything -- is working fine, and that this comment can be completely -- ignored. I'm leaving the comment anyway in case something -- breaks and you, poor reader, are investigating. updateTestDeps modBuildable test deps = let bi = testBuildInfo test bi' = bi { targetBuildDepends = deps , buildable = buildable bi && (if modBuildable then packageConfigEnableTests packageConfig else True) } in test { testBuildInfo = bi' } updateBenchmarkDeps modBuildable benchmark deps = let bi = benchmarkBuildInfo benchmark bi' = bi { targetBuildDepends = deps , buildable = buildable bi && (if modBuildable then packageConfigEnableBenchmarks packageConfig else True) } in benchmark { benchmarkBuildInfo = bi' } -- | Make a map from a list of flag specifications. -- -- What is @flagManual@ for? flagMap :: [Flag] -> Map FlagName Bool flagMap = M.fromList . map pair where pair :: Flag -> (FlagName, Bool) pair (MkFlag (fromCabalFlagName -> name) _desc def _manual) = (name,def) data ResolveConditions = ResolveConditions { rcFlags :: Map FlagName Bool , rcCompilerVersion :: CompilerVersion 'CVActual , rcOS :: OS , rcArch :: Arch } -- | Generic a @ResolveConditions@ using sensible defaults. mkResolveConditions :: CompilerVersion 'CVActual -- ^ Compiler version -> Platform -- ^ installation target platform -> Map FlagName Bool -- ^ enabled flags -> ResolveConditions mkResolveConditions compilerVersion (Platform arch os) flags = ResolveConditions { rcFlags = flags , rcCompilerVersion = compilerVersion , rcOS = os , rcArch = arch } -- | Resolve the condition tree for the library. resolveConditions :: (Semigroup target,Monoid target,Show target) => ResolveConditions -> (target -> cs -> target) -> CondTree ConfVar cs target -> target resolveConditions rc addDeps (CondNode lib deps cs) = basic <> children where basic = addDeps lib deps children = mconcat (map apply cs) where apply (Cabal.CondBranch cond node mcs) = if condSatisfied cond then resolveConditions rc addDeps node else maybe mempty (resolveConditions rc addDeps) mcs condSatisfied c = case c of Var v -> varSatisifed v Lit b -> b CNot c' -> not (condSatisfied c') COr cx cy -> condSatisfied cx || condSatisfied cy CAnd cx cy -> condSatisfied cx && condSatisfied cy varSatisifed v = case v of OS os -> os == rcOS rc Arch arch -> arch == rcArch rc Flag flag -> fromMaybe False $ M.lookup (fromCabalFlagName flag) (rcFlags rc) -- NOTE: ^^^^^ This should never happen, as all flags -- which are used must be declared. Defaulting to -- False. Impl flavor range -> case (flavor, rcCompilerVersion rc) of (GHC, GhcVersion vghc) -> vghc `withinRange` range (GHC, GhcjsVersion _ vghc) -> vghc `withinRange` range (GHCJS, GhcjsVersion vghcjs _) -> vghcjs `withinRange` range _ -> False -- | Get the name of a dependency. depName :: Dependency -> PackageName depName (Dependency n _) = fromCabalPackageName n -- | Get the version range of a dependency. depRange :: Dependency -> VersionRange depRange (Dependency _ r) = r -- | Try to resolve the list of base names in the given directory by -- looking for unique instances of base names applied with the given -- extensions, plus find any of their module and TemplateHaskell -- dependencies. resolveFilesAndDeps :: NamedComponent -- ^ Package component name -> [Path Abs Dir] -- ^ Directories to look in. -> [DotCabalDescriptor] -- ^ Base names. -> [Text] -- ^ Extensions. -> RIO Ctx (Map ModuleName (Path Abs File),Set DotCabalPath,[PackageWarning]) resolveFilesAndDeps component dirs names0 exts = do (dotCabalPaths, foundModules, missingModules) <- loop names0 S.empty warnings <- liftM2 (++) (warnUnlisted foundModules) (warnMissing missingModules) return (foundModules, dotCabalPaths, warnings) where loop [] _ = return (S.empty, M.empty, []) loop names doneModules0 = do resolved <- resolveFiles dirs names exts let foundFiles = mapMaybe snd resolved foundModules = mapMaybe toResolvedModule resolved missingModules = mapMaybe toMissingModule resolved pairs <- mapM (getDependencies component) foundFiles let doneModules = S.union doneModules0 (S.fromList (mapMaybe dotCabalModule names)) moduleDeps = S.unions (map fst pairs) thDepFiles = concatMap snd pairs modulesRemaining = S.difference moduleDeps doneModules -- Ignore missing modules discovered as dependencies - they may -- have been deleted. (resolvedFiles, resolvedModules, _) <- loop (map DotCabalModule (S.toList modulesRemaining)) doneModules return ( S.union (S.fromList (foundFiles <> map DotCabalFilePath thDepFiles)) resolvedFiles , M.union (M.fromList foundModules) resolvedModules , missingModules) warnUnlisted foundModules = do let unlistedModules = foundModules `M.difference` M.fromList (mapMaybe (fmap (, ()) . dotCabalModule) names0) return $ if M.null unlistedModules then [] else [ UnlistedModulesWarning component (map fst (M.toList unlistedModules))] warnMissing _missingModules = do return [] -- TODO: bring this back - see -- https://github.com/commercialhaskell/stack/issues/2649 {- cabalfp <- asks ctxFile return $ if null missingModules then [] else [ MissingModulesWarning cabalfp component missingModules] -} -- TODO: In usages of toResolvedModule / toMissingModule, some sort -- of map + partition would probably be better. toResolvedModule :: (DotCabalDescriptor, Maybe DotCabalPath) -> Maybe (ModuleName, Path Abs File) toResolvedModule (DotCabalModule mn, Just (DotCabalModulePath fp)) = Just (mn, fp) toResolvedModule _ = Nothing toMissingModule :: (DotCabalDescriptor, Maybe DotCabalPath) -> Maybe ModuleName toMissingModule (DotCabalModule mn, Nothing) = Just mn toMissingModule _ = Nothing -- | Get the dependencies of a Haskell module file. getDependencies :: NamedComponent -> DotCabalPath -> RIO Ctx (Set ModuleName, [Path Abs File]) getDependencies component dotCabalPath = case dotCabalPath of DotCabalModulePath resolvedFile -> readResolvedHi resolvedFile DotCabalMainPath resolvedFile -> readResolvedHi resolvedFile DotCabalFilePath{} -> return (S.empty, []) DotCabalCFilePath{} -> return (S.empty, []) where readResolvedHi resolvedFile = do dumpHIDir <- componentOutputDir component <$> asks ctxDistDir dir <- asks (parent . ctxFile) case stripProperPrefix dir resolvedFile of Nothing -> return (S.empty, []) Just fileRel -> do let dumpHIPath = FilePath.replaceExtension (toFilePath (dumpHIDir fileRel)) ".dump-hi" dumpHIExists <- liftIO $ D.doesFileExist dumpHIPath if dumpHIExists then parseDumpHI dumpHIPath else return (S.empty, []) -- | Parse a .dump-hi file into a set of modules and files. parseDumpHI :: FilePath -> RIO Ctx (Set ModuleName, [Path Abs File]) parseDumpHI dumpHIPath = do dir <- asks (parent . ctxFile) dumpHI <- liftIO $ filterDumpHi <$> fmap CL8.lines (CL8.readFile dumpHIPath) let startModuleDeps = dropWhile (not . ("module dependencies:" `CL8.isPrefixOf`)) dumpHI moduleDeps = S.fromList $ mapMaybe (D.simpleParse . TL.unpack . TLE.decodeUtf8) $ CL8.words $ CL8.concat $ CL8.dropWhile (/= ' ') (fromMaybe "" $ listToMaybe startModuleDeps) : takeWhile (" " `CL8.isPrefixOf`) (drop 1 startModuleDeps) thDeps = -- The dependent file path is surrounded by quotes but is not escaped. -- It can be an absolute or relative path. TL.unpack . -- Starting with GHC 8.4.3, there's a hash following -- the path. See -- https://github.com/yesodweb/yesod/issues/1551 TLE.decodeUtf8 . CL8.takeWhile (/= '\"') <$> mapMaybe (CL8.stripPrefix "addDependentFile \"") dumpHI thDepsResolved <- liftM catMaybes $ forM thDeps $ \x -> do mresolved <- liftIO (forgivingAbsence (resolveFile dir x)) >>= rejectMissingFile when (isNothing mresolved) $ prettyWarnL [ flow "addDependentFile path (Template Haskell) listed in" , styleFile $ fromString dumpHIPath , flow "does not exist:" , styleFile $ fromString x ] return mresolved return (moduleDeps, thDepsResolved) where -- | Filtering step fixing RAM usage upon a big dump-hi file. See -- https://github.com/commercialhaskell/stack/issues/4027 It is -- an optional step from a functionality stand-point. filterDumpHi dumpHI = let dl x xs = x ++ xs isLineInteresting (acc, moduleDepsStarted) l | moduleDepsStarted && " " `CL8.isPrefixOf` l = (acc . dl [l], True) | "module dependencies:" `CL8.isPrefixOf` l = (acc . dl [l], True) | "addDependentFile \"" `CL8.isPrefixOf` l = (acc . dl [l], False) | otherwise = (acc, False) in fst (foldl' isLineInteresting (dl [], False) dumpHI) [] -- | Try to resolve the list of base names in the given directory by -- looking for unique instances of base names applied with the given -- extensions. resolveFiles :: [Path Abs Dir] -- ^ Directories to look in. -> [DotCabalDescriptor] -- ^ Base names. -> [Text] -- ^ Extensions. -> RIO Ctx [(DotCabalDescriptor, Maybe DotCabalPath)] resolveFiles dirs names exts = forM names (\name -> liftM (name, ) (findCandidate dirs exts name)) -- | Find a candidate for the given module-or-filename from the list -- of directories and given extensions. findCandidate :: [Path Abs Dir] -> [Text] -> DotCabalDescriptor -> RIO Ctx (Maybe DotCabalPath) findCandidate dirs exts name = do pkg <- asks ctxFile >>= parsePackageNameFromFilePath candidates <- liftIO makeNameCandidates case candidates of [candidate] -> return (Just (cons candidate)) [] -> do case name of DotCabalModule mn | D.display mn /= paths_pkg pkg -> logPossibilities dirs mn _ -> return () return Nothing (candidate:rest) -> do warnMultiple name candidate rest return (Just (cons candidate)) where cons = case name of DotCabalModule{} -> DotCabalModulePath DotCabalMain{} -> DotCabalMainPath DotCabalFile{} -> DotCabalFilePath DotCabalCFile{} -> DotCabalCFilePath paths_pkg pkg = "Paths_" ++ packageNameString pkg makeNameCandidates = liftM (nubOrd . concat) (mapM makeDirCandidates dirs) makeDirCandidates :: Path Abs Dir -> IO [Path Abs File] makeDirCandidates dir = case name of DotCabalMain fp -> resolveCandidate dir fp DotCabalFile fp -> resolveCandidate dir fp DotCabalCFile fp -> resolveCandidate dir fp DotCabalModule mn -> liftM concat $ mapM ((\ ext -> resolveCandidate dir (Cabal.toFilePath mn ++ "." ++ ext)) . T.unpack) exts resolveCandidate :: (MonadIO m, MonadThrow m) => Path Abs Dir -> FilePath.FilePath -> m [Path Abs File] resolveCandidate x y = do -- The standard canonicalizePath does not work for this case p <- parseCollapsedAbsFile (toFilePath x FilePath. y) exists <- doesFileExist p return $ if exists then [p] else [] -- | Warn the user that multiple candidates are available for an -- entry, but that we picked one anyway and continued. warnMultiple :: DotCabalDescriptor -> Path b t -> [Path b t] -> RIO Ctx () warnMultiple name candidate rest = -- TODO: figure out how to style 'name' and the dispOne stuff prettyWarnL [ flow "There were multiple candidates for the Cabal entry \"" , fromString . showName $ name , line <> bulletedList (map dispOne rest) , line <> flow "picking:" , dispOne candidate ] where showName (DotCabalModule name') = D.display name' showName (DotCabalMain fp) = fp showName (DotCabalFile fp) = fp showName (DotCabalCFile fp) = fp dispOne = fromString . toFilePath -- TODO: figure out why dispOne can't be just `display` -- (remove the .hlint.yaml exception if it can be) -- | Log that we couldn't find a candidate, but there are -- possibilities for custom preprocessor extensions. -- -- For example: .erb for a Ruby file might exist in one of the -- directories. logPossibilities :: HasRunner env => [Path Abs Dir] -> ModuleName -> RIO env () logPossibilities dirs mn = do possibilities <- liftM concat (makePossibilities mn) unless (null possibilities) $ prettyWarnL [ flow "Unable to find a known candidate for the Cabal entry" , (styleModule . fromString $ D.display mn) <> "," , flow "but did find:" , line <> bulletedList (map display possibilities) , flow "If you are using a custom preprocessor for this module" , flow "with its own file extension, consider adding the file(s)" , flow "to your .cabal under extra-source-files." ] where makePossibilities name = mapM (\dir -> do (_,files) <- listDir dir return (map filename (filter (isPrefixOf (D.display name) . toFilePath . filename) files))) dirs -- | Get the filename for the cabal file in the given directory. -- -- If no .cabal file is present, or more than one is present, an exception is -- thrown via 'throwM'. -- -- If the directory contains a file named package.yaml, hpack is used to -- generate a .cabal file from it. findOrGenerateCabalFile :: forall env. HasConfig env => Path Abs Dir -- ^ package directory -> RIO env (Path Abs File) findOrGenerateCabalFile pkgDir = do hpack pkgDir findCabalFile where findCabalFile :: RIO env (Path Abs File) findCabalFile = findCabalFile' >>= either throwIO return findCabalFile' :: RIO env (Either PackageException (Path Abs File)) findCabalFile' = do files <- liftIO $ findFiles pkgDir (flip hasExtension "cabal" . FL.toFilePath) (const False) return $ case files of [] -> Left $ PackageNoCabalFileFound pkgDir [x] -> Right x -- If there are multiple files, ignore files that start with -- ".". On unixlike environments these are hidden, and this -- character is not valid in package names. The main goal is -- to ignore emacs lock files - see -- https://github.com/commercialhaskell/stack/issues/1897. (filter (not . ("." `isPrefixOf`) . toFilePath . filename) -> [x]) -> Right x _:_ -> Left $ PackageMultipleCabalFilesFound pkgDir files where hasExtension fp x = FilePath.takeExtension fp == "." ++ x -- | Generate .cabal file from package.yaml, if necessary. hpack :: HasConfig env => Path Abs Dir -> RIO env () hpack pkgDir = do let hpackFile = pkgDir $(mkRelFile Hpack.packageConfig) exists <- liftIO $ doesFileExist hpackFile when exists $ do prettyDebugL [flow "Running hpack on", display hpackFile] config <- view configL case configOverrideHpack config of HpackBundled -> do r <- liftIO $ Hpack.hpackResult $ Hpack.setProgramName "stack" $ Hpack.setTarget (toFilePath hpackFile) Hpack.defaultOptions forM_ (Hpack.resultWarnings r) prettyWarnS let cabalFile = styleFile . fromString . Hpack.resultCabalFile $ r case Hpack.resultStatus r of Hpack.Generated -> prettyDebugL [flow "hpack generated a modified version of", cabalFile] Hpack.OutputUnchanged -> prettyDebugL [flow "hpack output unchanged in", cabalFile] Hpack.AlreadyGeneratedByNewerHpack -> prettyWarnL [ cabalFile , flow "was generated with a newer version of hpack," , flow "please upgrade and try again." ] Hpack.ExistingCabalFileWasModifiedManually -> prettyWarnL [ cabalFile , flow "was modified manually. Ignoring" , display hpackFile , flow "in favor of the cabal file. If you want to use the" , display . filename $ hpackFile , flow "file instead of the cabal file," , flow "then please delete the cabal file." ] HpackCommand command -> withWorkingDir (toFilePath pkgDir) $ proc command [] runProcess_ -- | Path for the package's build log. buildLogPath :: (MonadReader env m, HasBuildConfig env, MonadThrow m) => Package -> Maybe String -> m (Path Abs File) buildLogPath package' msuffix = do env <- ask let stack = getProjectWorkDir env fp <- parseRelFile $ concat $ packageIdentifierString (packageIdentifier package') : maybe id (\suffix -> ("-" :) . (suffix :)) msuffix [".log"] return $ stack $(mkRelDir "logs") fp -- Internal helper to define resolveFileOrWarn and resolveDirOrWarn resolveOrWarn :: Text -> (Path Abs Dir -> String -> RIO Ctx (Maybe a)) -> FilePath.FilePath -> RIO Ctx (Maybe a) resolveOrWarn subject resolver path = do cwd <- liftIO getCurrentDir file <- asks ctxFile dir <- asks (parent . ctxFile) result <- resolver dir path when (isNothing result) $ prettyWarnL [ fromString . T.unpack $ subject -- TODO: needs style? , flow "listed in" , maybe (display file) display (stripProperPrefix cwd file) , flow "file does not exist:" , styleDir . fromString $ path ] return result -- | Resolve the file, if it can't be resolved, warn for the user -- (purely to be helpful). resolveFileOrWarn :: FilePath.FilePath -> RIO Ctx (Maybe (Path Abs File)) resolveFileOrWarn = resolveOrWarn "File" f where f p x = liftIO (forgivingAbsence (resolveFile p x)) >>= rejectMissingFile -- | Resolve the directory, if it can't be resolved, warn for the user -- (purely to be helpful). resolveDirOrWarn :: FilePath.FilePath -> RIO Ctx (Maybe (Path Abs Dir)) resolveDirOrWarn = resolveOrWarn "Directory" f where f p x = liftIO (forgivingAbsence (resolveDir p x)) >>= rejectMissingDir -- | Extract the @PackageIdentifier@ given an exploded haskell package -- path. cabalFilePackageId :: (MonadIO m, MonadThrow m) => Path Abs File -> m PackageIdentifier cabalFilePackageId fp = do pkgDescr <- liftIO (D.readGenericPackageDescription D.silent $ toFilePath fp) (toStackPI . D.package . D.packageDescription) pkgDescr where toStackPI (D.PackageIdentifier (D.unPackageName -> name) ver) = do name' <- parsePackageNameFromString name let ver' = fromCabalVersion ver return (PackageIdentifier name' ver') stack-1.9.3.1/src/Stack/PackageDump.hs0000644000000000000000000004303713455617610015546 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude #-} {-# LANGUAGE FlexibleContexts #-} {-# LANGUAGE GeneralizedNewtypeDeriving #-} {-# LANGUAGE RankNTypes #-} {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TupleSections #-} {-# LANGUAGE DeriveDataTypeable #-} {-# LANGUAGE DeriveGeneric #-} {-# LANGUAGE TemplateHaskell #-} module Stack.PackageDump ( Line , eachSection , eachPair , DumpPackage (..) , conduitDumpPackage , ghcPkgDump , ghcPkgDescribe , newInstalledCache , loadInstalledCache , saveInstalledCache , addProfiling , addHaddock , addSymbols , sinkMatching , pruneDeps ) where import Stack.Prelude import Data.Attoparsec.Args import Data.Attoparsec.Text as P import Data.Conduit import qualified Data.Conduit.List as CL import qualified Data.Conduit.Text as CT import Data.List (isPrefixOf) import qualified Data.Map as Map import qualified Data.Set as Set import Data.Store.VersionTagged import qualified Data.Text as T import qualified Distribution.License as C import qualified Distribution.System as OS import qualified Distribution.Text as C import Path.Extra (toFilePathNoTrailingSep) import Stack.GhcPkg import Stack.Types.Compiler import Stack.Types.GhcPkgId import Stack.Types.PackageDump import Stack.Types.PackageIdentifier import Stack.Types.PackageName import Stack.Types.Version import System.Directory (getDirectoryContents, doesFileExist) import System.Process (readProcess) -- FIXME confirm that this is correct import RIO.Process hiding (readProcess) -- | Call ghc-pkg dump with appropriate flags and stream to the given @Sink@, for a single database ghcPkgDump :: (HasProcessContext env, HasLogFunc env) => WhichCompiler -> [Path Abs Dir] -- ^ if empty, use global -> ConduitM Text Void (RIO env) a -> RIO env a ghcPkgDump = ghcPkgCmdArgs ["dump"] -- | Call ghc-pkg describe with appropriate flags and stream to the given @Sink@, for a single database ghcPkgDescribe :: (HasProcessContext env, HasLogFunc env) => PackageName -> WhichCompiler -> [Path Abs Dir] -- ^ if empty, use global -> ConduitM Text Void (RIO env) a -> RIO env a ghcPkgDescribe pkgName = ghcPkgCmdArgs ["describe", "--simple-output", packageNameString pkgName] -- | Call ghc-pkg and stream to the given @Sink@, for a single database ghcPkgCmdArgs :: (HasProcessContext env, HasLogFunc env) => [String] -> WhichCompiler -> [Path Abs Dir] -- ^ if empty, use global -> ConduitM Text Void (RIO env) a -> RIO env a ghcPkgCmdArgs cmd wc mpkgDbs sink = do case reverse mpkgDbs of (pkgDb:_) -> createDatabase wc pkgDb -- TODO maybe use some retry logic instead? _ -> return () sinkProcessStdout (ghcPkgExeName wc) args sink' where args = concat [ case mpkgDbs of [] -> ["--global", "--no-user-package-db"] _ -> ["--user", "--no-user-package-db"] ++ concatMap (\pkgDb -> ["--package-db", toFilePathNoTrailingSep pkgDb]) mpkgDbs , cmd , ["--expand-pkgroot"] ] sink' = CT.decodeUtf8 .| sink -- | Create a new, empty @InstalledCache@ newInstalledCache :: MonadIO m => m InstalledCache newInstalledCache = liftIO $ InstalledCache <$> newIORef (InstalledCacheInner Map.empty) -- | Load a @InstalledCache@ from disk, swallowing any errors and returning an -- empty cache. loadInstalledCache :: HasLogFunc env => Path Abs File -> RIO env InstalledCache loadInstalledCache path = do m <- $(versionedDecodeOrLoad installedCacheVC) path (return $ InstalledCacheInner Map.empty) liftIO $ InstalledCache <$> newIORef m -- | Save a @InstalledCache@ to disk saveInstalledCache :: HasLogFunc env => Path Abs File -> InstalledCache -> RIO env () saveInstalledCache path (InstalledCache ref) = liftIO (readIORef ref) >>= $(versionedEncodeFile installedCacheVC) path -- | Prune a list of possible packages down to those whose dependencies are met. -- -- * id uniquely identifies an item -- -- * There can be multiple items per name pruneDeps :: (Ord name, Ord id) => (id -> name) -- ^ extract the name from an id -> (item -> id) -- ^ the id of an item -> (item -> [id]) -- ^ get the dependencies of an item -> (item -> item -> item) -- ^ choose the desired of two possible items -> [item] -- ^ input items -> Map name item pruneDeps getName getId getDepends chooseBest = Map.fromList . fmap (getName . getId &&& id) . loop Set.empty Set.empty [] where loop foundIds usedNames foundItems dps = case partitionEithers $ map depsMet dps of ([], _) -> foundItems (s', dps') -> let foundIds' = Map.fromListWith chooseBest s' foundIds'' = Set.fromList $ map getId $ Map.elems foundIds' usedNames' = Map.keysSet foundIds' foundItems' = Map.elems foundIds' in loop (Set.union foundIds foundIds'') (Set.union usedNames usedNames') (foundItems ++ foundItems') (catMaybes dps') where depsMet dp | name `Set.member` usedNames = Right Nothing | all (`Set.member` foundIds) (getDepends dp) = Left (name, dp) | otherwise = Right $ Just dp where id' = getId dp name = getName id' -- | Find the package IDs matching the given constraints with all dependencies installed. -- Packages not mentioned in the provided @Map@ are allowed to be present too. sinkMatching :: Monad m => Bool -- ^ require profiling? -> Bool -- ^ require haddock? -> Bool -- ^ require debugging symbols? -> Map PackageName Version -- ^ allowed versions -> ConduitM (DumpPackage Bool Bool Bool) o m (Map PackageName (DumpPackage Bool Bool Bool)) sinkMatching reqProfiling reqHaddock reqSymbols allowed = Map.fromList . map (packageIdentifierName . dpPackageIdent &&& id) . Map.elems . pruneDeps id dpGhcPkgId dpDepends const -- Could consider a better comparison in the future <$> (CL.filter predicate .| CL.consume) where predicate dp = isAllowed (dpPackageIdent dp) && (not reqProfiling || dpProfiling dp) && (not reqHaddock || dpHaddock dp) && (not reqSymbols || dpSymbols dp) isAllowed (PackageIdentifier name version) = case Map.lookup name allowed of Just version' | version /= version' -> False _ -> True -- | Add profiling information to the stream of @DumpPackage@s addProfiling :: MonadIO m => InstalledCache -> ConduitM (DumpPackage a b c) (DumpPackage Bool b c) m () addProfiling (InstalledCache ref) = CL.mapM go where go dp = liftIO $ do InstalledCacheInner m <- readIORef ref let gid = dpGhcPkgId dp p <- case Map.lookup gid m of Just installed -> return (installedCacheProfiling installed) Nothing | null (dpLibraries dp) -> return True Nothing -> do let loop [] = return False loop (dir:dirs) = do econtents <- tryIO $ getDirectoryContents dir let contents = either (const []) id econtents if or [isProfiling content lib | content <- contents , lib <- dpLibraries dp ] && not (null contents) then return True else loop dirs loop $ dpLibDirs dp return dp { dpProfiling = p } isProfiling :: FilePath -- ^ entry in directory -> Text -- ^ name of library -> Bool isProfiling content lib = prefix `T.isPrefixOf` T.pack content where prefix = T.concat ["lib", lib, "_p"] -- | Add haddock information to the stream of @DumpPackage@s addHaddock :: MonadIO m => InstalledCache -> ConduitM (DumpPackage a b c) (DumpPackage a Bool c) m () addHaddock (InstalledCache ref) = CL.mapM go where go dp = liftIO $ do InstalledCacheInner m <- readIORef ref let gid = dpGhcPkgId dp h <- case Map.lookup gid m of Just installed -> return (installedCacheHaddock installed) Nothing | not (dpHasExposedModules dp) -> return True Nothing -> do let loop [] = return False loop (ifc:ifcs) = do exists <- doesFileExist ifc if exists then return True else loop ifcs loop $ dpHaddockInterfaces dp return dp { dpHaddock = h } -- | Add debugging symbol information to the stream of @DumpPackage@s addSymbols :: MonadIO m => InstalledCache -> ConduitM (DumpPackage a b c) (DumpPackage a b Bool) m () addSymbols (InstalledCache ref) = CL.mapM go where go dp = do InstalledCacheInner m <- liftIO $ readIORef ref let gid = dpGhcPkgId dp s <- case Map.lookup gid m of Just installed -> return (installedCacheSymbols installed) Nothing | null (dpLibraries dp) -> return True Nothing -> case dpLibraries dp of [] -> return True lib:_ -> liftM or . mapM (\dir -> liftIO $ hasDebuggingSymbols dir (T.unpack lib)) $ dpLibDirs dp return dp { dpSymbols = s } hasDebuggingSymbols :: FilePath -- ^ library directory -> String -- ^ name of library -> IO Bool hasDebuggingSymbols dir lib = do let path = concat [dir, "/lib", lib, ".a"] exists <- doesFileExist path if not exists then return False else case OS.buildOS of OS.OSX -> liftM (any (isPrefixOf "0x") . lines) $ readProcess "dwarfdump" [path] "" OS.Linux -> liftM (any (isPrefixOf "Contents") . lines) $ readProcess "readelf" ["--debug-dump=info", "--dwarf-depth=1", path] "" OS.FreeBSD -> liftM (any (isPrefixOf "Contents") . lines) $ readProcess "readelf" ["--debug-dump=info", "--dwarf-depth=1", path] "" OS.Windows -> return False -- No support, so it can't be there. _ -> return False -- | Dump information for a single package data DumpPackage profiling haddock symbols = DumpPackage { dpGhcPkgId :: !GhcPkgId , dpPackageIdent :: !PackageIdentifier , dpParentLibIdent :: !(Maybe PackageIdentifier) , dpLicense :: !(Maybe C.License) , dpLibDirs :: ![FilePath] , dpLibraries :: ![Text] , dpHasExposedModules :: !Bool , dpExposedModules :: ![Text] , dpDepends :: ![GhcPkgId] , dpHaddockInterfaces :: ![FilePath] , dpHaddockHtml :: !(Maybe FilePath) , dpProfiling :: !profiling , dpHaddock :: !haddock , dpSymbols :: !symbols , dpIsExposed :: !Bool } deriving (Show, Eq) data PackageDumpException = MissingSingleField Text (Map Text [Line]) | Couldn'tParseField Text [Line] deriving Typeable instance Exception PackageDumpException instance Show PackageDumpException where show (MissingSingleField name values) = unlines $ return (concat [ "Expected single value for field name " , show name , " when parsing ghc-pkg dump output:" ]) ++ map (\(k, v) -> " " ++ show (k, v)) (Map.toList values) show (Couldn'tParseField name ls) = "Couldn't parse the field " ++ show name ++ " from lines: " ++ show ls -- | Convert a stream of bytes into a stream of @DumpPackage@s conduitDumpPackage :: MonadThrow m => ConduitM Text (DumpPackage () () ()) m () conduitDumpPackage = (.| CL.catMaybes) $ eachSection $ do pairs <- eachPair (\k -> (k, ) <$> CL.consume) .| CL.consume let m = Map.fromList pairs let parseS k = case Map.lookup k m of Just [v] -> return v _ -> throwM $ MissingSingleField k m -- Can't fail: if not found, same as an empty list. See: -- https://github.com/fpco/stack/issues/182 parseM k = Map.findWithDefault [] k m parseDepend :: MonadThrow m => Text -> m (Maybe GhcPkgId) parseDepend "builtin_rts" = return Nothing parseDepend bs = liftM Just $ parseGhcPkgId bs' where (bs', _builtinRts) = case stripSuffixText " builtin_rts" bs of Nothing -> case stripPrefixText "builtin_rts " bs of Nothing -> (bs, False) Just x -> (x, True) Just x -> (x, True) case Map.lookup "id" m of Just ["builtin_rts"] -> return Nothing _ -> do name <- parseS "name" >>= parsePackageName version <- parseS "version" >>= parseVersion ghcPkgId <- parseS "id" >>= parseGhcPkgId -- if a package has no modules, these won't exist let libDirKey = "library-dirs" libraries = parseM "hs-libraries" exposedModules = parseM "exposed-modules" exposed = parseM "exposed" license = case parseM "license" of [licenseText] -> C.simpleParse (T.unpack licenseText) _ -> Nothing depends <- mapMaybeM parseDepend $ concatMap T.words $ parseM "depends" -- Handle sublibs by recording the name of the parent library -- If name of parent library is missing, this is not a sublib. let mkParentLib n = PackageIdentifier n version parentLib = mkParentLib <$> (parseS "package-name" >>= parsePackageName) let parseQuoted key = case mapM (P.parseOnly (argsParser NoEscaping)) val of Left{} -> throwM (Couldn'tParseField key val) Right dirs -> return (concat dirs) where val = parseM key libDirPaths <- parseQuoted libDirKey haddockInterfaces <- parseQuoted "haddock-interfaces" haddockHtml <- parseQuoted "haddock-html" return $ Just DumpPackage { dpGhcPkgId = ghcPkgId , dpPackageIdent = PackageIdentifier name version , dpParentLibIdent = parentLib , dpLicense = license , dpLibDirs = libDirPaths , dpLibraries = T.words $ T.unwords libraries , dpHasExposedModules = not (null libraries || null exposedModules) , dpExposedModules = T.words $ T.unwords exposedModules , dpDepends = depends , dpHaddockInterfaces = haddockInterfaces , dpHaddockHtml = listToMaybe haddockHtml , dpProfiling = () , dpHaddock = () , dpSymbols = () , dpIsExposed = exposed == ["True"] } stripPrefixText :: Text -> Text -> Maybe Text stripPrefixText x y | x `T.isPrefixOf` y = Just $ T.drop (T.length x) y | otherwise = Nothing stripSuffixText :: Text -> Text -> Maybe Text stripSuffixText x y | x `T.isSuffixOf` y = Just $ T.take (T.length y - T.length x) y | otherwise = Nothing -- | A single line of input, not including line endings type Line = Text -- | Apply the given Sink to each section of output, broken by a single line containing --- eachSection :: Monad m => ConduitM Line Void m a -> ConduitM Text a m () eachSection inner = CL.map (T.filter (/= '\r')) .| CT.lines .| start where peekText = await >>= maybe (return Nothing) (\bs -> if T.null bs then peekText else leftover bs >> return (Just bs)) start = peekText >>= maybe (return ()) (const go) go = do x <- toConsumer $ takeWhileC (/= "---") .| inner yield x CL.drop 1 start -- | Grab each key/value pair eachPair :: Monad m => (Text -> ConduitM Line Void m a) -> ConduitM Line a m () eachPair inner = start where start = await >>= maybe (return ()) start' start' bs1 = toConsumer (valSrc .| inner key) >>= yield >> start where (key, bs2) = T.break (== ':') bs1 (spaces, bs3) = T.span (== ' ') $ T.drop 1 bs2 indent = T.length key + 1 + T.length spaces valSrc | T.null bs3 = noIndent | otherwise = yield bs3 >> loopIndent indent noIndent = do mx <- await case mx of Nothing -> return () Just bs -> do let (spaces, val) = T.span (== ' ') bs if T.length spaces == 0 then leftover val else do yield val loopIndent (T.length spaces) loopIndent i = loop where loop = await >>= maybe (return ()) go go bs | T.length spaces == i && T.all (== ' ') spaces = yield val >> loop | otherwise = leftover bs where (spaces, val) = T.splitAt i bs -- | General purpose utility takeWhileC :: Monad m => (a -> Bool) -> ConduitM a a m () takeWhileC f = loop where loop = await >>= maybe (return ()) go go x | f x = yield x >> loop | otherwise = leftover x stack-1.9.3.1/src/Stack/PackageIndex.hs0000644000000000000000000005151013455617610015703 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude #-} {-# LANGUAGE BangPatterns #-} {-# LANGUAGE CPP #-} {-# LANGUAGE ConstraintKinds #-} {-# LANGUAGE DataKinds #-} {-# LANGUAGE DeriveDataTypeable #-} {-# LANGUAGE DeriveGeneric #-} {-# LANGUAGE FlexibleContexts #-} {-# LANGUAGE GADTs #-} {-# LANGUAGE GeneralizedNewtypeDeriving #-} {-# LANGUAGE KindSignatures #-} {-# LANGUAGE LambdaCase #-} {-# LANGUAGE MultiParamTypeClasses #-} {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE PatternGuards #-} {-# LANGUAGE RankNTypes #-} {-# LANGUAGE TemplateHaskell #-} {-# LANGUAGE TupleSections #-} {-# LANGUAGE ViewPatterns #-} {-# LANGUAGE ScopedTypeVariables #-} -- | Dealing with the 01-index file and all its cabal files. module Stack.PackageIndex ( updateAllIndices , getPackageCaches , getPackageVersions , lookupPackageVersions , CabalLoader (..) , HasCabalLoader (..) , configPackageIndex , configPackageIndexRoot ) where import qualified Codec.Archive.Tar as Tar import Stack.Prelude import Data.Aeson.Extended import qualified Data.ByteString.Char8 as B8 import qualified Data.ByteString.Lazy as L import Data.Conduit.Zlib (ungzip) import qualified Data.List.NonEmpty as NE import qualified Data.HashMap.Strict as HashMap import Data.Store.Version import Data.Store.VersionTagged import qualified Data.Text as T import Data.Text.Unsafe (unsafeTail) import Data.Time (getCurrentTime) import qualified Hackage.Security.Client as HS import qualified Hackage.Security.Client.Repository.Cache as HS import qualified Hackage.Security.Client.Repository.Remote as HS import qualified Hackage.Security.Client.Repository.HttpLib.HttpClient as HS import qualified Hackage.Security.Util.Path as HS import qualified Hackage.Security.Util.Pretty as HS import Network.HTTP.StackClient (getGlobalManager) import Network.HTTP.Download import Network.URI (parseURI) import Path (toFilePath, parseAbsFile, mkRelDir, mkRelFile, (), parseRelDir) import Path.Extra (tryGetModificationTime) import Path.IO import Stack.Types.PackageIdentifier import Stack.Types.PackageIndex import Stack.Types.PackageName import Stack.Types.Runner (HasRunner) import Stack.Types.Version import qualified System.Directory as D import System.FilePath ((<.>)) -- | Populate the package index caches and return them. populateCache :: HasCabalLoader env => PackageIndex -> RIO env (PackageCache ()) populateCache index = do requireIndex index -- This uses full on lazy I/O instead of ResourceT to provide some -- protections. Caveat emptor path <- configPackageIndex (indexName index) let loadPIS = withLazyFile (Path.toFilePath path) $ \lbs -> do logSticky "Populating index cache ..." loop 0 HashMap.empty (Tar.read lbs) pis0 <- loadPIS `catch` \e -> do logWarn $ "Exception encountered when parsing index tarball: " <> displayShow (e :: Tar.FormatError) logWarn "Automatically updating index and trying again" updateIndex index loadPIS when (indexRequireHashes index) $ forM_ (HashMap.toList pis0) $ \(ident, (mpd, _)) -> case mpd :: Maybe PackageDownload of Just _ -> return () Nothing -> throwM $ MissingRequiredHashes (indexName index) ident cache <- fmap mconcat $ mapM convertPI $ HashMap.toList pis0 logStickyDone "Populated index cache." return cache where convertPI :: MonadIO m => (PackageIdentifier, (Maybe PackageDownload, Endo [([CabalHash], OffsetSize)])) -> m (PackageCache ()) convertPI (ident@(PackageIdentifier name version), (mpd, Endo front)) = case NE.nonEmpty $ front [] of Nothing -> throwString $ "Missing cabal file info for: " ++ show ident Just files -> return $ PackageCache $ HashMap.singleton name $ HashMap.singleton version ((), mpd, files) loop :: MonadThrow m => Int64 -> HashMap PackageIdentifier (Maybe PackageDownload, Endo [([CabalHash], OffsetSize)]) -> Tar.Entries Tar.FormatError -> m (HashMap PackageIdentifier (Maybe PackageDownload, Endo [([CabalHash], OffsetSize)])) loop !blockNo !m (Tar.Next e es) = loop (blockNo + entrySizeInBlocks e) (goE blockNo m e) es loop _ m Tar.Done = return m loop _ _ (Tar.Fail e) = throwM e goE :: Int64 -> HashMap PackageIdentifier (Maybe PackageDownload, Endo [([CabalHash], OffsetSize)]) -> Tar.Entry -> HashMap PackageIdentifier (Maybe PackageDownload, Endo [([CabalHash], OffsetSize)]) goE blockNo m e = case Tar.entryContent e of Tar.NormalFile lbs size -> case parseNameVersionSuffix $ Tar.entryPath e of Just (ident, ".cabal") -> addCabal lbs ident size Just (ident, ".json") -> addJSON id ident lbs _ -> case parsePackageJSON $ Tar.entryPath e of Just ident -> addJSON unHSPackageDownload ident lbs Nothing -> m _ -> m where addCabal lbs ident size = HashMap.alter (\case Nothing -> Just (Nothing, newEndo) Just (mpd, oldEndo) -> Just (mpd, oldEndo <> newEndo)) ident m where !cabalHash = computeCabalHash lbs -- Some older Stackage snapshots ended up with slightly -- modified cabal files, in particular having DOS-style -- line endings (CRLF) converted to Unix-style (LF). As a -- result, we track both hashes with and without CR -- characters stripped for compatibility with these older -- snapshots. cr = 13 cabalHashes | cr `L.elem` lbs = let !cabalHash' = computeCabalHash (L.filter (/= cr) lbs) in [cabalHash, cabalHash'] | otherwise = [cabalHash] offsetSize = OffsetSize ((blockNo + 1) * 512) size newPair = (cabalHashes, offsetSize) newEndo = Endo (newPair:) addJSON :: FromJSON a => (a -> PackageDownload) -> PackageIdentifier -> L.ByteString -> HashMap PackageIdentifier (Maybe PackageDownload, Endo [([CabalHash], OffsetSize)]) addJSON unwrap ident lbs = case decode lbs of Nothing -> m Just (unwrap -> pd) -> HashMap.alter (\case Nothing -> Just (Just pd, mempty) Just (Just oldPD, _) | oldPD /= pd -> error $ concat [ "Conflicting package hash information discovered for " , packageIdentifierString ident , "\nFound both: \n- " , show oldPD , "\n- " , show pd , "\n\nThis should not happen. See: https://github.com/haskell/hackage-security/issues/189" ] Just (_, files) -> Just (Just pd, files)) ident m breakSlash x | T.null z = Nothing | otherwise = Just (y, unsafeTail z) where (y, z) = T.break (== '/') x parseNameVersion t1 = do (p', t3) <- breakSlash $ T.map (\c -> if c == '\\' then '/' else c) $ T.pack t1 p <- parsePackageName p' (v', t5) <- breakSlash t3 v <- parseVersion v' return (p', p, v, t5) parseNameVersionSuffix t1 = do (p', p, v, t5) <- parseNameVersion t1 let (t6, suffix) = T.break (== '.') t5 guard $ t6 == p' return (PackageIdentifier p v, suffix) parsePackageJSON t1 = do (_, p, v, t5) <- parseNameVersion t1 guard $ t5 == "package.json" return $ PackageIdentifier p v data PackageIndexException = GitNotAvailable IndexName | MissingRequiredHashes IndexName PackageIdentifier deriving Typeable instance Exception PackageIndexException instance Show PackageIndexException where show (GitNotAvailable name) = concat [ "Package index " , T.unpack $ indexNameText name , " only provides Git access, and you do not have" , " the git executable on your PATH" ] show (MissingRequiredHashes name ident) = concat [ "Package index " , T.unpack $ indexNameText name , " is configured to require package hashes, but no" , " hash is available for " , packageIdentifierString ident ] -- | Require that an index be present, updating if it isn't. requireIndex :: HasCabalLoader env => PackageIndex -> RIO env () requireIndex index = do tarFile <- configPackageIndex $ indexName index exists <- doesFileExist tarFile unless exists $ updateIndex index -- | Update all of the package indices updateAllIndices :: HasCabalLoader env => RIO env () updateAllIndices = do clearPackageCaches cl <- view cabalLoaderL mapM_ updateIndex (clIndices cl) -- | Update the index tarball updateIndex :: HasCabalLoader env => PackageIndex -> RIO env () updateIndex index = do let name = indexName index url = indexLocation index logSticky $ "Updating package index " <> display (indexNameText (indexName index)) <> " (mirrored at " <> display url <> ") ..." case indexType index of ITVanilla -> updateIndexHTTP name url ITHackageSecurity hs -> updateIndexHackageSecurity name url hs logStickyDone "Update complete" -- Copy to the 00-index.tar filename for backwards -- compatibility. First wipe out the cache file if present. tarFile <- configPackageIndex name oldTarFile <- configPackageIndexOld name oldCacheFile <- configPackageIndexCacheOld name liftIO $ ignoringAbsence (removeFile oldCacheFile) withSourceFile (toFilePath tarFile) $ \src -> withSinkFile (toFilePath oldTarFile) $ \sink -> runConduit $ src .| sink -- | Update the index tarball via HTTP updateIndexHTTP :: HasCabalLoader env => IndexName -> Text -- ^ url -> RIO env () updateIndexHTTP indexName' url = do req <- parseRequest $ T.unpack url logInfo ("Downloading package index from " <> display url) gz <- configPackageIndexGz indexName' tar <- configPackageIndex indexName' wasDownloaded <- redownload req gz shouldUnpack <- if wasDownloaded then return True else not `liftM` doesFileExist tar if not shouldUnpack then packageIndexNotUpdated indexName' else do let tmp = toFilePath tar <.> "tmp" tmpPath <- parseAbsFile tmp deleteCache indexName' liftIO $ do withSourceFile (toFilePath gz) $ \input -> withSinkFile tmp $ \output -> -- FIXME use withSinkFileCautious runConduit $ input .| ungzip .| output renameFile tmpPath tar -- | Update the index tarball via Hackage Security updateIndexHackageSecurity :: HasCabalLoader env => IndexName -> Text -- ^ base URL -> HackageSecurity -> RIO env () updateIndexHackageSecurity indexName' url (HackageSecurity keyIds threshold) = do baseURI <- case parseURI $ T.unpack url of Nothing -> throwString $ "Invalid Hackage Security base URL: " ++ T.unpack url Just x -> return x manager <- liftIO getGlobalManager root <- configPackageIndexRoot indexName' run <- askRunInIO let logTUF = run . logInfo . fromString . HS.pretty withRepo = HS.withRepository (HS.makeHttpLib manager) [baseURI] HS.defaultRepoOpts HS.Cache { HS.cacheRoot = HS.fromAbsoluteFilePath $ toFilePath root , HS.cacheLayout = HS.cabalCacheLayout -- Have Hackage Security write to a temporary file -- to avoid invalidating the cache... continued -- below at case didUpdate { HS.cacheLayoutIndexTar = HS.rootPath $ HS.fragment "01-index.tar-tmp" } } HS.hackageRepoLayout HS.hackageIndexLayout logTUF didUpdate <- liftIO $ withRepo $ \repo -> HS.uncheckClientErrors $ do needBootstrap <- HS.requiresBootstrap repo when needBootstrap $ do HS.bootstrap repo (map (HS.KeyId . T.unpack) keyIds) (HS.KeyThreshold (fromIntegral threshold)) now <- getCurrentTime HS.checkForUpdates repo (Just now) case didUpdate of HS.NoUpdates -> packageIndexNotUpdated indexName' HS.HasUpdates -> do -- The index actually updated. Delete the old cache, and -- then move the temporary unpacked file to its real -- location tar <- configPackageIndex indexName' deleteCache indexName' liftIO $ D.renameFile (toFilePath tar ++ "-tmp") (toFilePath tar) logInfo "Updated package index downloaded" -- If the index is newer than the cache, delete it so that -- the next 'getPackageCaches' call recomputes it. This -- could happen if a prior run of stack updated the index, -- but exited before deleting the cache. -- -- See https://github.com/commercialhaskell/stack/issues/3033 packageIndexNotUpdated :: HasCabalLoader env => IndexName -> RIO env () packageIndexNotUpdated indexName' = do mindexModTime <- tryGetModificationTime =<< configPackageIndex indexName' mcacheModTime <- tryGetModificationTime =<< configPackageIndexCache indexName' case (mindexModTime, mcacheModTime) of (Right indexModTime, Right cacheModTime) | cacheModTime < indexModTime -> do deleteCache indexName' logInfo "No updates to your package index were found, but clearing the index cache as it is older than the index." (Left _, _) -> do deleteCache indexName' logError "Error: No updates to your package index were found, but downloaded index is missing." _ -> logInfo "No updates to your package index were found" -- | Delete the package index cache deleteCache :: HasCabalLoader env => IndexName -> RIO env () deleteCache indexName' = do fp <- configPackageIndexCache indexName' eres <- liftIO $ tryIO $ removeFile fp case eres of Left e -> logDebug $ "Could not delete cache: " <> displayShow e Right () -> logDebug $ "Deleted index cache at " <> fromString (toFilePath fp) -- | Get the known versions for a given package from the package caches. -- -- See 'getPackageCaches' for performance notes. getPackageVersions :: HasCabalLoader env => PackageName -> RIO env (HashMap Version (Maybe CabalHash)) getPackageVersions pkgName = lookupPackageVersions pkgName <$> getPackageCaches lookupPackageVersions :: PackageName -> PackageCache index -> HashMap Version (Maybe CabalHash) lookupPackageVersions pkgName (PackageCache m) = maybe HashMap.empty (HashMap.map extractOrigRevHash) $ HashMap.lookup pkgName m where -- Extract the original cabal file hash (the first element of the one or two -- element list currently representing the cabal file hashes). extractOrigRevHash (_,_, neRevHashesAndOffsets) = listToMaybe $ fst (NE.last neRevHashesAndOffsets) -- | Load the package caches, or create the caches if necessary. -- -- This has two levels of caching: in memory, and the on-disk cache. So, -- feel free to call this function multiple times. getPackageCaches :: HasCabalLoader env => RIO env (PackageCache PackageIndex) getPackageCaches = do cl <- view cabalLoaderL mcached <- readIORef (clCache cl) case mcached of Just cached -> return cached Nothing -> do result <- liftM mconcat $ forM (clIndices cl) $ \index -> do fp <- configPackageIndexCache (indexName index) PackageCache pis <- #if MIN_VERSION_template_haskell(2,14,0) $(versionedDecodeOrLoad (storeVersionConfig "pkg-v5" "35_zXZ4b4CIWfrLXtjWteR4nb6o=" #elif MIN_VERSION_template_haskell(2,13,0) $(versionedDecodeOrLoad (storeVersionConfig "pkg-v5" "LLL6OCcimOqRm3r0JmsSlLHcaLE=" #else $(versionedDecodeOrLoad (storeVersionConfig "pkg-v5" "A607WaDwhg5VVvZTxNgU9g52DO8=" #endif :: VersionConfig (PackageCache ()))) fp (populateCache index) return $ PackageCache ((fmap.fmap) (\((), mpd, files) -> (index, mpd, files)) pis) liftIO $ writeIORef (clCache cl) (Just result) return result -- | Clear the in-memory hackage index cache. This is needed when the -- hackage index is updated. clearPackageCaches :: HasCabalLoader env => RIO env () clearPackageCaches = do cl <- view cabalLoaderL writeIORef (clCache cl) Nothing class HasRunner env => HasCabalLoader env where cabalLoaderL :: Lens' env CabalLoader data CabalLoader = CabalLoader { clCache :: !(IORef (Maybe (PackageCache PackageIndex))) , clIndices :: ![PackageIndex] -- ^ Information on package indices. This is left biased, meaning that -- packages in an earlier index will shadow those in a later index. -- -- Warning: if you override packages in an index vs what's available -- upstream, you may correct your compiled snapshots, as different -- projects may have different definitions of what pkg-ver means! This -- feature is primarily intended for adding local packages, not -- overriding. Overriding is better accomplished by adding to your -- list of packages. -- -- Note that indices specified in a later config file will override -- previous indices, /not/ extend them. -- -- Using an assoc list instead of a Map to keep track of priority , clStackRoot :: !(Path Abs Dir) -- ^ ~/.stack more often than not , clUpdateRef :: !(MVar Bool) -- ^ Want to try updating the index once during a single run for missing -- package identifiers. We also want to ensure we only update once at a -- time. Start at @True@. -- -- TODO: probably makes sense to move this concern into getPackageCaches , clConnectionCount :: !Int -- ^ How many concurrent connections are allowed when downloading , clIgnoreRevisionMismatch :: !Bool -- ^ Ignore a revision mismatch when loading up cabal files, -- and fall back to the latest revision. See: -- } -- | Root for a specific package index configPackageIndexRoot :: HasCabalLoader env => IndexName -> RIO env (Path Abs Dir) configPackageIndexRoot (IndexName name) = do cl <- view cabalLoaderL let root = clStackRoot cl dir <- parseRelDir $ B8.unpack name return (root $(mkRelDir "indices") dir) -- | Location of the 01-index.tar file configPackageIndex :: HasCabalLoader env => IndexName -> RIO env (Path Abs File) configPackageIndex name = ( $(mkRelFile "01-index.tar")) <$> configPackageIndexRoot name -- | Location of the 01-index.cache file configPackageIndexCache :: HasCabalLoader env => IndexName -> RIO env (Path Abs File) configPackageIndexCache name = ( $(mkRelFile "01-index.cache")) <$> configPackageIndexRoot name -- | Location of the 00-index.cache file configPackageIndexCacheOld :: HasCabalLoader env => IndexName -> RIO env (Path Abs File) configPackageIndexCacheOld = liftM ( $(mkRelFile "00-index.cache")) . configPackageIndexRoot -- | Location of the 00-index.tar file. This file is just a copy of -- the 01-index.tar file, provided for tools which still look for the -- 00-index.tar file. configPackageIndexOld :: HasCabalLoader env => IndexName -> RIO env (Path Abs File) configPackageIndexOld = liftM ( $(mkRelFile "00-index.tar")) . configPackageIndexRoot -- | Location of the 01-index.tar.gz file configPackageIndexGz :: HasCabalLoader env => IndexName -> RIO env (Path Abs File) configPackageIndexGz = liftM ( $(mkRelFile "01-index.tar.gz")) . configPackageIndexRoot --------------- Lifted from cabal-install, Distribution.Client.Tar: -- | Return the number of blocks in an entry. entrySizeInBlocks :: Tar.Entry -> Int64 entrySizeInBlocks entry = 1 + case Tar.entryContent entry of Tar.NormalFile _ size -> bytesToBlocks size Tar.OtherEntryType _ _ size -> bytesToBlocks size _ -> 0 where bytesToBlocks s = 1 + ((fromIntegral s - 1) `div` 512) stack-1.9.3.1/src/Stack/PackageLocation.hs0000644000000000000000000002637413455617610016416 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude #-} {-# LANGUAGE FlexibleContexts #-} {-# LANGUAGE LambdaCase #-} {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE TemplateHaskell #-} {-# LANGUAGE TupleSections #-} -- | Deal with downloading, cloning, or whatever else is necessary for -- getting a 'PackageLocation' into something Stack can work with. module Stack.PackageLocation ( resolveSinglePackageLocation , resolveMultiPackageLocation , parseSingleCabalFile , parseSingleCabalFileIndex , parseMultiCabalFiles , parseMultiCabalFilesIndex ) where import qualified Codec.Archive.Tar as Tar import qualified Codec.Archive.Zip as Zip import qualified Codec.Compression.GZip as GZip import Stack.Prelude import Crypto.Hash (hashWith, SHA256(..)) import qualified Data.ByteArray as Mem (convert) import qualified Data.ByteString as S import qualified Data.ByteString.Base64.URL as B64URL import qualified Data.Text as T import Data.Text.Encoding (encodeUtf8, decodeUtf8) import Distribution.PackageDescription (GenericPackageDescription) import Network.HTTP.StackClient (parseUrlThrow) import Network.HTTP.Download.Verified import Path import Path.Extra import Path.IO import Stack.Package import Stack.Types.BuildPlan import Stack.Types.Config import Stack.Types.PackageIdentifier import qualified System.Directory as Dir import RIO.Process -- | Same as 'resolveMultiPackageLocation', but works on a -- 'SinglePackageLocation'. resolveSinglePackageLocation :: HasConfig env => Path Abs Dir -- ^ project root -> PackageLocation FilePath -> RIO env (Path Abs Dir) resolveSinglePackageLocation projRoot (PLFilePath fp) = resolveDir projRoot fp resolveSinglePackageLocation projRoot (PLArchive (Archive url subdir msha)) = do workDir <- view workDirL -- TODO: dedupe with code for snapshot hash? let name = T.unpack $ decodeUtf8 $ S.take 12 $ B64URL.encode $ Mem.convert $ hashWith SHA256 $ encodeUtf8 url root = projRoot workDir $(mkRelDir "downloaded") fileExtension' = ".http-archive" fileRel <- parseRelFile $ name ++ fileExtension' dirRel <- parseRelDir name dirRelTmp <- parseRelDir $ name ++ ".tmp" let fileDownload = root fileRel dir = root dirRel exists <- doesDirExist dir unless exists $ do liftIO $ ignoringAbsence (removeDirRecur dir) let dirTmp = root dirRelTmp liftIO $ ignoringAbsence (removeDirRecur dirTmp) urlExists <- liftIO $ Dir.doesFileExist $ T.unpack url file <- if urlExists then do file <- liftIO $ Dir.canonicalizePath (T.unpack url) >>= parseAbsFile case msha of Nothing -> return () Just sha -> do actualSha <- mkStaticSHA256FromFile file when (sha /= actualSha) $ error $ concat [ "Invalid SHA256 found for local archive " , show file , "\nExpected: " , T.unpack $ staticSHA256ToText sha , "\nActual: " , T.unpack $ staticSHA256ToText actualSha ] return file else do req <- parseUrlThrow $ T.unpack url let dreq = DownloadRequest { drRequest = req , drHashChecks = case msha of Nothing -> [] Just sha -> [HashCheck { hashCheckAlgorithm = SHA256 , hashCheckHexDigest = CheckHexDigestByteString $ staticSHA256ToBase16 sha }] , drLengthCheck = Nothing -- TODO add length info? , drRetryPolicy = drRetryPolicyDefault } _ <- verifiedDownload dreq fileDownload (const $ return ()) return fileDownload let fp = toFilePath file withLazyFile fp $ \lbs -> do -- Share a single file read among all of the different -- parsing attempts. We're not worried about unbounded -- memory usage, as we will detect almost immediately if -- this is the wrong type of file. let tryTargz = do logDebug $ "Trying to ungzip/untar " <> fromString fp let entries = Tar.read $ GZip.decompress lbs liftIO $ Tar.unpack (toFilePath dirTmp) entries tryZip = do logDebug $ "Trying to unzip " <> fromString fp let archive = Zip.toArchive lbs liftIO $ Zip.extractFilesFromArchive [Zip.OptDestination (toFilePath dirTmp)] archive tryTar = do logDebug $ "Trying to untar (no ungzip) " <> fromString fp let entries = Tar.read lbs liftIO $ Tar.unpack (toFilePath dirTmp) entries err = throwM $ UnableToExtractArchive url file catchAnyLog goodpath handler = catchAny goodpath $ \e -> do logDebug $ "Got exception: " <> displayShow e handler tryTargz `catchAnyLog` tryZip `catchAnyLog` tryTar `catchAnyLog` err renameDir dirTmp dir x <- listDir dir case x of ([dir'], []) -> resolveDir dir' subdir (dirs, files) -> liftIO $ do ignoringAbsence (removeFile fileDownload) ignoringAbsence (removeDirRecur dir) throwIO $ UnexpectedArchiveContents dirs files resolveSinglePackageLocation projRoot (PLRepo (Repo url commit repoType' subdir)) = cloneRepo projRoot url commit repoType' >>= flip resolveDir subdir -- | Resolve a PackageLocation into a path, downloading and cloning as -- necessary. -- -- Returns the updated PackageLocation value with just a single subdir -- (if relevant). resolveMultiPackageLocation :: HasConfig env => Path Abs Dir -- ^ project root -> PackageLocation Subdirs -> RIO env [(Path Abs Dir, PackageLocation FilePath)] resolveMultiPackageLocation y (PLFilePath fp) = do dir <- resolveSinglePackageLocation y (PLFilePath fp) return [(dir, PLFilePath fp)] resolveMultiPackageLocation y (PLArchive (Archive url subdirs msha)) = do dir <- resolveSinglePackageLocation y (PLArchive (Archive url "." msha)) let subdirs' = case subdirs of DefaultSubdirs -> ["."] ExplicitSubdirs subs -> subs forM subdirs' $ \subdir -> do dir' <- resolveDir dir subdir return (dir', PLArchive (Archive url subdir msha)) resolveMultiPackageLocation projRoot (PLRepo (Repo url commit repoType' subdirs)) = do dir <- cloneRepo projRoot url commit repoType' let subdirs' = case subdirs of DefaultSubdirs -> ["."] ExplicitSubdirs subs -> subs forM subdirs' $ \subdir -> do dir' <- resolveDir dir subdir return (dir', PLRepo $ Repo url commit repoType' subdir) cloneRepo :: HasConfig env => Path Abs Dir -- ^ project root -> Text -- ^ URL -> Text -- ^ commit -> RepoType -> RIO env (Path Abs Dir) cloneRepo projRoot url commit repoType' = do workDir <- view workDirL let nameBeforeHashing = case repoType' of RepoGit -> T.unwords [url, commit] RepoHg -> T.unwords [url, commit, "hg"] -- TODO: dedupe with code for snapshot hash? name = T.unpack $ decodeUtf8 $ S.take 12 $ B64URL.encode $ Mem.convert $ hashWith SHA256 $ encodeUtf8 nameBeforeHashing root = projRoot workDir $(mkRelDir "downloaded") dirRel <- parseRelDir name let dir = root dirRel exists <- doesDirExist dir unless exists $ do liftIO $ ignoringAbsence (removeDirRecur dir) let cloneAndExtract commandName cloneArgs resetCommand = withWorkingDir (toFilePath root) $ do ensureDir root logInfo $ "Cloning " <> display commit <> " from " <> display url proc commandName ("clone" : cloneArgs ++ [ T.unpack url , toFilePathNoTrailingSep dir ]) runProcess_ created <- doesDirExist dir unless created $ throwM $ FailedToCloneRepo commandName withWorkingDir (toFilePath dir) $ readProcessNull commandName (resetCommand ++ [T.unpack commit, "--"]) `catchAny` \case ex -> do logInfo $ "Please ensure that commit " <> display commit <> " exists within " <> display url throwM ex case repoType' of RepoGit -> cloneAndExtract "git" ["--recursive"] ["--git-dir=.git", "reset", "--hard"] RepoHg -> cloneAndExtract "hg" [] ["--repository", ".", "update", "-C"] return dir -- | Parse the cabal files present in the given -- 'PackageLocationIndex FilePath'. parseSingleCabalFileIndex :: forall env. HasConfig env => Path Abs Dir -- ^ project root, used for checking out necessary files -> PackageLocationIndex FilePath -> RIO env GenericPackageDescription -- Need special handling of PLIndex for efficiency (just read from the -- index tarball) and correctness (get the cabal file from the index, -- not the package tarball itself, yay Hackage revisions). parseSingleCabalFileIndex _ (PLIndex pir) = readPackageUnresolvedIndex pir parseSingleCabalFileIndex root (PLOther loc) = lpvGPD <$> parseSingleCabalFile root False loc parseSingleCabalFile :: forall env. HasConfig env => Path Abs Dir -- ^ project root, used for checking out necessary files -> Bool -- ^ print warnings? -> PackageLocation FilePath -> RIO env LocalPackageView parseSingleCabalFile root printWarnings loc = do dir <- resolveSinglePackageLocation root loc (gpd, cabalfp) <- readPackageUnresolvedDir dir printWarnings return LocalPackageView { lpvCabalFP = cabalfp , lpvGPD = gpd , lpvLoc = loc } -- | Load and parse cabal files into 'GenericPackageDescription's parseMultiCabalFiles :: forall env. HasConfig env => Path Abs Dir -- ^ project root, used for checking out necessary files -> Bool -- ^ print warnings? -> PackageLocation Subdirs -> RIO env [LocalPackageView] parseMultiCabalFiles root printWarnings loc0 = resolveMultiPackageLocation root loc0 >>= mapM (\(dir, loc1) -> do (gpd, cabalfp) <- readPackageUnresolvedDir dir printWarnings return LocalPackageView { lpvCabalFP = cabalfp , lpvGPD = gpd , lpvLoc = loc1 }) -- | 'parseMultiCabalFiles' but supports 'PLIndex' parseMultiCabalFilesIndex :: forall env. HasConfig env => Path Abs Dir -- ^ project root, used for checking out necessary files -> PackageLocationIndex Subdirs -> RIO env [(GenericPackageDescription, PackageLocationIndex FilePath)] parseMultiCabalFilesIndex _root (PLIndex pir) = pure . (, PLIndex pir) <$> readPackageUnresolvedIndex pir parseMultiCabalFilesIndex root (PLOther loc0) = map (\lpv -> (lpvGPD lpv, PLOther $ lpvLoc lpv)) <$> parseMultiCabalFiles root False loc0 stack-1.9.3.1/src/Stack/Path.hs0000644000000000000000000002126313455617610014256 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude #-} {-# LANGUAGE FlexibleContexts #-} {-# LANGUAGE OverloadedStrings #-} -- | Handy path information. module Stack.Path ( path , pathParser ) where import Stack.Prelude import Data.List (intercalate) import qualified Data.Set as Set import qualified Data.Text as T import qualified Data.Text.IO as T import Lens.Micro (lens) import qualified Options.Applicative as OA import Path import Path.Extra import Stack.Constants import Stack.Constants.Config import Stack.GhcPkg as GhcPkg import Stack.PackageIndex (HasCabalLoader (..)) import Stack.Types.Config import Stack.Types.Runner import qualified System.FilePath as FP import System.IO (stderr) import RIO.Process (HasProcessContext (..), exeSearchPathL) -- | Print out useful path information in a human-readable format (and -- support others later). path :: HasEnvConfig env => [Text] -> RIO env () path keys = do -- We must use a BuildConfig from an EnvConfig to ensure that it contains the -- full environment info including GHC paths etc. bc <- view $ envConfigL.buildConfigL -- This is the modified 'bin-path', -- including the local GHC or MSYS if not configured to operate on -- global GHC. -- It was set up in 'withBuildConfigAndLock -> withBuildConfigExt -> setupEnv'. -- So it's not the *minimal* override path. snap <- packageDatabaseDeps plocal <- packageDatabaseLocal extra <- packageDatabaseExtra whichCompiler <- view $ actualCompilerVersionL.whichCompilerL global <- GhcPkg.getGlobalDB whichCompiler snaproot <- installationRootDeps localroot <- installationRootLocal toolsDir <- bindirCompilerTools distDir <- distRelativeDir hpcDir <- hpcReportDir compiler <- getCompilerPath whichCompiler let deprecated = filter ((`elem` keys) . fst) deprecatedPathKeys liftIO $ forM_ deprecated $ \(oldOption, newOption) -> T.hPutStrLn stderr $ T.unlines [ "" , "'--" <> oldOption <> "' will be removed in a future release." , "Please use '--" <> newOption <> "' instead." , "" ] forM_ -- filter the chosen paths in flags (keys), -- or show all of them if no specific paths chosen. (filter (\(_,key,_) -> (null keys && key /= T.pack deprecatedStackRootOptionName) || elem key keys) paths) (\(_,key,path') -> liftIO $ T.putStrLn -- If a single path type is requested, output it directly. -- Otherwise, name all the paths. ((if length keys == 1 then "" else key <> ": ") <> path' (PathInfo bc snap plocal global snaproot localroot toolsDir distDir hpcDir extra compiler))) pathParser :: OA.Parser [Text] pathParser = mapMaybeA (\(desc,name,_) -> OA.flag Nothing (Just name) (OA.long (T.unpack name) <> OA.help desc)) paths -- | Passed to all the path printers as a source of info. data PathInfo = PathInfo { piBuildConfig :: BuildConfig , piSnapDb :: Path Abs Dir , piLocalDb :: Path Abs Dir , piGlobalDb :: Path Abs Dir , piSnapRoot :: Path Abs Dir , piLocalRoot :: Path Abs Dir , piToolsDir :: Path Abs Dir , piDistDir :: Path Rel Dir , piHpcDir :: Path Abs Dir , piExtraDbs :: [Path Abs Dir] , piCompiler :: Path Abs File } instance HasPlatform PathInfo instance HasLogFunc PathInfo where logFuncL = configL.logFuncL instance HasRunner PathInfo where runnerL = configL.runnerL instance HasConfig PathInfo instance HasCabalLoader PathInfo where cabalLoaderL = configL.cabalLoaderL instance HasProcessContext PathInfo where processContextL = configL.processContextL instance HasBuildConfig PathInfo where buildConfigL = lens piBuildConfig (\x y -> x { piBuildConfig = y }) . buildConfigL -- | The paths of interest to a user. The first tuple string is used -- for a description that the optparse flag uses, and the second -- string as a machine-readable key and also for @--foo@ flags. The user -- can choose a specific path to list like @--stack-root@. But -- really it's mainly for the documentation aspect. -- -- When printing output we generate @PathInfo@ and pass it to the -- function to generate an appropriate string. Trailing slashes are -- removed, see #506 paths :: [(String, Text, PathInfo -> Text)] paths = [ ( "Global stack root directory" , T.pack stackRootOptionName , view $ stackRootL.to toFilePathNoTrailingSep.to T.pack) , ( "Project root (derived from stack.yaml file)" , "project-root" , view $ projectRootL.to toFilePathNoTrailingSep.to T.pack) , ( "Configuration location (where the stack.yaml file is)" , "config-location" , view $ stackYamlL.to toFilePath.to T.pack) , ( "PATH environment variable" , "bin-path" , T.pack . intercalate [FP.searchPathSeparator] . view exeSearchPathL) , ( "Install location for GHC and other core tools" , "programs" , view $ configL.to configLocalPrograms.to toFilePathNoTrailingSep.to T.pack) , ( "Compiler binary (e.g. ghc)" , "compiler-exe" , T.pack . toFilePath . piCompiler ) , ( "Directory containing the compiler binary (e.g. ghc)" , "compiler-bin" , T.pack . toFilePathNoTrailingSep . parent . piCompiler ) , ( "Directory containing binaries specific to a particular compiler (e.g. intero)" , "compiler-tools-bin" , T.pack . toFilePathNoTrailingSep . piToolsDir ) , ( "Local bin dir where stack installs executables (e.g. ~/.local/bin)" , "local-bin" , view $ configL.to configLocalBin.to toFilePathNoTrailingSep.to T.pack) , ( "Extra include directories" , "extra-include-dirs" , T.intercalate ", " . map T.pack . Set.elems . configExtraIncludeDirs . view configL ) , ( "Extra library directories" , "extra-library-dirs" , T.intercalate ", " . map T.pack . Set.elems . configExtraLibDirs . view configL ) , ( "Snapshot package database" , "snapshot-pkg-db" , T.pack . toFilePathNoTrailingSep . piSnapDb ) , ( "Local project package database" , "local-pkg-db" , T.pack . toFilePathNoTrailingSep . piLocalDb ) , ( "Global package database" , "global-pkg-db" , T.pack . toFilePathNoTrailingSep . piGlobalDb ) , ( "GHC_PACKAGE_PATH environment variable" , "ghc-package-path" , \pi' -> mkGhcPackagePath True (piLocalDb pi') (piSnapDb pi') (piExtraDbs pi') (piGlobalDb pi')) , ( "Snapshot installation root" , "snapshot-install-root" , T.pack . toFilePathNoTrailingSep . piSnapRoot ) , ( "Local project installation root" , "local-install-root" , T.pack . toFilePathNoTrailingSep . piLocalRoot ) , ( "Snapshot documentation root" , "snapshot-doc-root" , \pi' -> T.pack (toFilePathNoTrailingSep (piSnapRoot pi' docDirSuffix))) , ( "Local project documentation root" , "local-doc-root" , \pi' -> T.pack (toFilePathNoTrailingSep (piLocalRoot pi' docDirSuffix))) , ( "Dist work directory, relative to package directory" , "dist-dir" , T.pack . toFilePathNoTrailingSep . piDistDir ) , ( "Where HPC reports and tix files are stored" , "local-hpc-root" , T.pack . toFilePathNoTrailingSep . piHpcDir ) , ( "DEPRECATED: Use '--local-bin' instead" , "local-bin-path" , T.pack . toFilePathNoTrailingSep . configLocalBin . view configL ) , ( "DEPRECATED: Use '--programs' instead" , "ghc-paths" , T.pack . toFilePathNoTrailingSep . configLocalPrograms . view configL ) , ( "DEPRECATED: Use '--" <> stackRootOptionName <> "' instead" , T.pack deprecatedStackRootOptionName , T.pack . toFilePathNoTrailingSep . view stackRootL ) ] deprecatedPathKeys :: [(Text, Text)] deprecatedPathKeys = [ (T.pack deprecatedStackRootOptionName, T.pack stackRootOptionName) , ("ghc-paths", "programs") , ("local-bin-path", "local-bin") ] stack-1.9.3.1/src/Stack/Prelude.hs0000644000000000000000000002021213455666157014765 0ustar0000000000000000{-# LANGUAGE CPP #-} {-# LANGUAGE NoImplicitPrelude #-} {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE ScopedTypeVariables #-} module Stack.Prelude ( withSourceFile , withSinkFile , withSinkFileCautious , withSystemTempDir , withKeepSystemTempDir , sinkProcessStderrStdout , sinkProcessStdout , logProcessStderrStdout , readProcessNull , withProcessContext , stripCR , hIsTerminalDeviceOrMinTTY , prompt , promptPassword , promptBool , module X ) where import RIO as X import Data.Conduit as X (ConduitM, runConduit, (.|)) import Path as X (Abs, Dir, File, Path, Rel, toFilePath) import Data.Monoid as X (First (..), Any (..), Sum (..), Endo (..)) import qualified Path.IO import qualified System.IO as IO import qualified System.Directory as Dir import qualified System.FilePath as FP import System.IO.Echo (withoutInputEcho) import System.IO.Error (isDoesNotExistError) #ifdef WINDOWS import System.Win32 (isMinTTYHandle, withHandleToHANDLE) #endif import Data.Conduit.Binary (sourceHandle, sinkHandle) import qualified Data.Conduit.Binary as CB import qualified Data.Conduit.List as CL import Data.Conduit.Process.Typed (withLoggedProcess_, createSource) import RIO.Process (HasProcessContext (..), ProcessContext, setStdin, closed, getStderr, getStdout, proc, withProcess_, setStdout, setStderr, ProcessConfig, readProcess_, workingDirL) import Data.Store as X (Store) import Data.Text.Encoding (decodeUtf8With) import Data.Text.Encoding.Error (lenientDecode) import qualified Data.Text.IO as T import qualified RIO.Text as T -- | Get a source for a file. Unlike @sourceFile@, doesn't require -- @ResourceT@. Unlike explicit @withBinaryFile@ and @sourceHandle@ -- usage, you can't accidentally use @WriteMode@ instead of -- @ReadMode@. withSourceFile :: MonadUnliftIO m => FilePath -> (ConduitM i ByteString m () -> m a) -> m a withSourceFile fp inner = withBinaryFile fp ReadMode $ inner . sourceHandle -- | Same idea as 'withSourceFile', see comments there. withSinkFile :: MonadUnliftIO m => FilePath -> (ConduitM ByteString o m () -> m a) -> m a withSinkFile fp inner = withBinaryFile fp WriteMode $ inner . sinkHandle -- | Like 'withSinkFile', but ensures that the file is atomically -- moved after all contents are written. withSinkFileCautious :: MonadUnliftIO m => FilePath -> (ConduitM ByteString o m () -> m a) -> m a withSinkFileCautious fp inner = withRunInIO $ \run -> bracket acquire cleanup $ \(tmpFP, h) -> run (inner $ sinkHandle h) <* (IO.hClose h *> Dir.renameFile tmpFP fp) where acquire = IO.openBinaryTempFile (FP.takeDirectory fp) (FP.takeFileName fp FP.<.> "tmp") cleanup (tmpFP, h) = do IO.hClose h Dir.removeFile tmpFP `catch` \e -> if isDoesNotExistError e then return () else throwIO e -- | Path version withSystemTempDir :: MonadUnliftIO m => String -> (Path Abs Dir -> m a) -> m a withSystemTempDir str inner = withRunInIO $ \run -> Path.IO.withSystemTempDir str $ run . inner -- | Like `withSystemTempDir`, but the temporary directory is not deleted. withKeepSystemTempDir :: MonadUnliftIO m => String -> (Path Abs Dir -> m a) -> m a withKeepSystemTempDir str inner = withRunInIO $ \run -> do path <- Path.IO.getTempDir dir <- Path.IO.createTempDir path str run $ inner dir -- | Consume the stdout and stderr of a process feeding strict 'ByteString's to the consumers. -- -- Throws a 'ReadProcessException' if unsuccessful in launching, or 'ProcessExitedUnsuccessfully' if the process itself fails. sinkProcessStderrStdout :: forall e o env. (HasProcessContext env, HasLogFunc env, HasCallStack) => String -- ^ Command -> [String] -- ^ Command line arguments -> ConduitM ByteString Void (RIO env) e -- ^ Sink for stderr -> ConduitM ByteString Void (RIO env) o -- ^ Sink for stdout -> RIO env (e,o) sinkProcessStderrStdout name args sinkStderr sinkStdout = proc name args $ \pc0 -> do let pc = setStdout createSource $ setStderr createSource pc0 withProcess_ pc $ \p -> runConduit (getStderr p .| sinkStderr) `concurrently` runConduit (getStdout p .| sinkStdout) -- | Consume the stdout of a process feeding strict 'ByteString's to a consumer. -- If the process fails, spits out stdout and stderr as error log -- level. Should not be used for long-running processes or ones with -- lots of output; for that use 'sinkProcessStderrStdout'. -- -- Throws a 'ReadProcessException' if unsuccessful. sinkProcessStdout :: (HasProcessContext env, HasLogFunc env, HasCallStack) => String -- ^ Command -> [String] -- ^ Command line arguments -> ConduitM ByteString Void (RIO env) a -- ^ Sink for stdout -> RIO env a sinkProcessStdout name args sinkStdout = proc name args $ \pc -> withLoggedProcess_ (setStdin closed pc) $ \p -> runConcurrently $ Concurrently (runConduit $ getStderr p .| CL.sinkNull) *> Concurrently (runConduit $ getStdout p .| sinkStdout) logProcessStderrStdout :: (HasCallStack, HasProcessContext env, HasLogFunc env) => ProcessConfig stdin stdoutIgnored stderrIgnored -> RIO env () logProcessStderrStdout pc = withLoggedProcess_ pc $ \p -> let logLines = CB.lines .| CL.mapM_ (logInfo . displayBytesUtf8) in runConcurrently $ Concurrently (runConduit $ getStdout p .| logLines) *> Concurrently (runConduit $ getStderr p .| logLines) -- | Read from the process, ignoring any output. -- -- Throws a 'ReadProcessException' exception if the process fails. readProcessNull :: (HasProcessContext env, HasLogFunc env, HasCallStack) => String -- ^ Command -> [String] -- ^ Command line arguments -> RIO env () readProcessNull name args = -- We want the output to appear in any exceptions, so we capture and drop it void $ proc name args readProcess_ -- | Use the new 'ProcessContext', but retain the working directory -- from the parent environment. withProcessContext :: HasProcessContext env => ProcessContext -> RIO env a -> RIO env a withProcessContext pcNew inner = do pcOld <- view processContextL let pcNew' = set workingDirL (view workingDirL pcOld) pcNew local (set processContextL pcNew') inner -- | Remove a trailing carriage return if present stripCR :: Text -> Text stripCR = T.dropSuffix "\r" -- | hIsTerminaDevice does not recognise handles to mintty terminals as terminal -- devices, but isMinTTYHandle does. hIsTerminalDeviceOrMinTTY :: MonadIO m => Handle -> m Bool #ifdef WINDOWS hIsTerminalDeviceOrMinTTY h = do isTD <- hIsTerminalDevice h if isTD then return True else liftIO $ withHandleToHANDLE h isMinTTYHandle #else hIsTerminalDeviceOrMinTTY = hIsTerminalDevice #endif -- | Prompt the user by sending text to stdout, and taking a line of -- input from stdin. prompt :: MonadIO m => Text -> m Text prompt txt = liftIO $ do T.putStr txt hFlush stdout T.getLine -- | Prompt the user by sending text to stdout, and collecting a line -- of input from stdin. While taking input from stdin, input echoing is -- disabled, to hide passwords. -- -- Based on code from cabal-install, Distribution.Client.Upload promptPassword :: MonadIO m => Text -> m Text promptPassword txt = liftIO $ do T.putStr txt hFlush stdout -- Save/restore the terminal echoing status (no echoing for entering -- the password). password <- withoutInputEcho T.getLine -- Since the user's newline is not echoed, one needs to be inserted. T.putStrLn "" return password -- | Prompt the user by sending text to stdout, and collecting a line of -- input from stdin. If something other than "y" or "n" is entered, then -- print a message indicating that "y" or "n" is expected, and ask -- again. promptBool :: MonadIO m => Text -> m Bool promptBool txt = liftIO $ do input <- prompt txt case input of "y" -> return True "n" -> return False _ -> do T.putStrLn "Please press either 'y' or 'n', and then enter." promptBool txt stack-1.9.3.1/src/Stack/PrettyPrint.hs0000644000000000000000000002306513455617610015670 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude #-} {-# OPTIONS_GHC -fno-warn-orphans #-} {-# LANGUAGE FlexibleContexts #-} {-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE OverloadedStrings #-} module Stack.PrettyPrint ( -- * Pretty printing functions displayPlain, displayWithColor -- * Logging based on pretty-print typeclass , prettyDebug, prettyInfo, prettyNote, prettyWarn, prettyError, prettyWarnNoIndent, prettyErrorNoIndent , prettyDebugL, prettyInfoL, prettyNoteL, prettyWarnL, prettyErrorL, prettyWarnNoIndentL, prettyErrorNoIndentL , prettyDebugS, prettyInfoS, prettyNoteS, prettyWarnS, prettyErrorS, prettyWarnNoIndentS, prettyErrorNoIndentS -- * Semantic styling functions -- | These are preferred to styling or colors directly, so that we can -- encourage consistency. , styleWarning, styleError, styleGood , styleShell, styleFile, styleUrl, styleDir, styleModule , styleCurrent, styleTarget , styleRecommendation , displayMilliseconds -- * Formatting utils , bulletedList , spacedBulletedList , debugBracket -- * Re-exports from "Text.PrettyPrint.Leijen.Extended" , Display(..), AnsiDoc, AnsiAnn(..), HasAnsiAnn(..), Doc , nest, line, linebreak, group, softline, softbreak , align, hang, indent, encloseSep , (<+>) , hsep, vsep, fillSep, sep, hcat, vcat, fillCat, cat, punctuate , fill, fillBreak , enclose, squotes, dquotes, parens, angles, braces, brackets , indentAfterLabel, wordDocs, flow ) where import qualified RIO import Stack.Prelude hiding (Display (..)) import Data.List (intersperse) import qualified Data.Text as T import qualified Distribution.ModuleName as C (ModuleName) import qualified Distribution.Text as C (display) import Stack.Types.NamedComponent import Stack.Types.PackageIdentifier import Stack.Types.PackageName import Stack.Types.Runner import Stack.Types.Version import Text.PrettyPrint.Leijen.Extended displayWithColor :: (HasRunner env, Display a, HasAnsiAnn (Ann a), MonadReader env m, HasLogFunc env, HasCallStack) => a -> m T.Text displayWithColor x = do useAnsi <- view useColorL termWidth <- view $ runnerL.to runnerTermWidth return $ (if useAnsi then displayAnsi else displayPlain) termWidth x -- TODO: switch to using implicit callstacks once 7.8 support is dropped prettyWith :: (HasRunner env, HasCallStack, Display b, HasAnsiAnn (Ann b), MonadReader env m, MonadIO m) => LogLevel -> (a -> b) -> a -> m () prettyWith level f = logGeneric "" level . RIO.display <=< displayWithColor . f -- Note: I think keeping this section aligned helps spot errors, might be -- worth keeping the alignment in place. prettyDebugWith, prettyInfoWith, prettyNoteWith, prettyWarnWith, prettyErrorWith, prettyWarnNoIndentWith, prettyErrorNoIndentWith :: (HasCallStack, HasRunner env, MonadReader env m, MonadIO m) => (a -> Doc AnsiAnn) -> a -> m () prettyDebugWith = prettyWith LevelDebug prettyInfoWith = prettyWith LevelInfo prettyNoteWith f = prettyWith LevelInfo ((line <>) . (styleGood "Note:" <+>) . indentAfterLabel . f) prettyWarnWith f = prettyWith LevelWarn ((line <>) . (styleWarning "Warning:" <+>) . indentAfterLabel . f) prettyErrorWith f = prettyWith LevelError ((line <>) . (styleError "Error:" <+>) . indentAfterLabel . f) prettyWarnNoIndentWith f = prettyWith LevelWarn ((line <>) . (styleWarning "Warning:" <+>) . f) prettyErrorNoIndentWith f = prettyWith LevelError ((line <>) . (styleError "Error:" <+>) . f) prettyDebug, prettyInfo, prettyNote, prettyWarn, prettyError, prettyWarnNoIndent, prettyErrorNoIndent :: (HasCallStack, HasRunner env, MonadReader env m, MonadIO m) => Doc AnsiAnn -> m () prettyDebug = prettyDebugWith id prettyInfo = prettyInfoWith id prettyNote = prettyNoteWith id prettyWarn = prettyWarnWith id prettyError = prettyErrorWith id prettyWarnNoIndent = prettyWarnNoIndentWith id prettyErrorNoIndent = prettyErrorNoIndentWith id prettyDebugL, prettyInfoL, prettyNoteL, prettyWarnL, prettyErrorL, prettyWarnNoIndentL, prettyErrorNoIndentL :: (HasCallStack, HasRunner env, MonadReader env m, MonadIO m) => [Doc AnsiAnn] -> m () prettyDebugL = prettyDebugWith fillSep prettyInfoL = prettyInfoWith fillSep prettyNoteL = prettyNoteWith fillSep prettyWarnL = prettyWarnWith fillSep prettyErrorL = prettyErrorWith fillSep prettyWarnNoIndentL = prettyWarnNoIndentWith fillSep prettyErrorNoIndentL = prettyErrorNoIndentWith fillSep prettyDebugS, prettyInfoS, prettyNoteS, prettyWarnS, prettyErrorS, prettyWarnNoIndentS, prettyErrorNoIndentS :: (HasCallStack, HasRunner env, MonadReader env m, MonadIO m) => String -> m () prettyDebugS = prettyDebugWith flow prettyInfoS = prettyInfoWith flow prettyNoteS = prettyNoteWith flow prettyWarnS = prettyWarnWith flow prettyErrorS = prettyErrorWith flow prettyWarnNoIndentS = prettyWarnNoIndentWith flow prettyErrorNoIndentS = prettyErrorNoIndentWith flow -- End of aligned section -- | Use after a label and before the rest of what's being labelled for -- consistent spacing/indenting/etc. -- -- For example this is used after "Warning:" in warning messages. indentAfterLabel :: Doc a -> Doc a indentAfterLabel = align -- | Make a 'Doc' from each word in a 'String' wordDocs :: String -> [Doc a] wordDocs = map fromString . words -- | Wordwrap a 'String' flow :: String -> Doc a flow = fillSep . wordDocs debugBracket :: (HasCallStack, HasRunner env, MonadReader env m, MonadIO m, MonadUnliftIO m) => Doc AnsiAnn -> m a -> m a debugBracket msg f = do let output = logDebug . RIO.display <=< displayWithColor output $ "Start: " <> msg start <- getMonotonicTime x <- f `catch` \ex -> do end <- getMonotonicTime let diff = end - start output $ "Finished with exception in" <+> displayMilliseconds diff <> ":" <+> msg <> line <> "Exception thrown: " <> fromString (show ex) throwIO (ex :: SomeException) end <- getMonotonicTime let diff = end - start output $ "Finished in" <+> displayMilliseconds diff <> ":" <+> msg return x -- The following syles do not affect the colour of the background. -- | Style an 'AnsiDoc' as an error. Should be used sparingly, not to style -- entire long messages. For example, it's used to style the "Error:" -- label for an error message, not the entire message. styleError :: AnsiDoc -> AnsiDoc styleError = dullred -- | Style an 'AnsiDoc' as a warning. Should be used sparingly, not to style -- entire long messages. For example, it's used to style the "Warning:" -- label for an error message, not the entire message. styleWarning :: AnsiDoc -> AnsiDoc styleWarning = dullyellow -- | Style an 'AnsiDoc' in a way to emphasize that it is a particularly good -- thing. styleGood :: AnsiDoc -> AnsiDoc styleGood = green -- | Style an 'AnsiDoc' as a shell command, i.e. when suggesting something -- to the user that should be typed in directly as written. styleShell :: AnsiDoc -> AnsiDoc styleShell = magenta -- | Style an 'AnsiDoc' as a filename. See 'styleDir' for directories. styleFile :: AnsiDoc -> AnsiDoc styleFile = dullcyan -- | Style an 'AsciDoc' as a URL. For now using the same style as files. styleUrl :: AnsiDoc -> AnsiDoc styleUrl = styleFile -- | Style an 'AnsiDoc' as a directory name. See 'styleFile' for files. styleDir :: AnsiDoc -> AnsiDoc styleDir = bold . blue -- | Style used to highlight part of a recommended course of action. styleRecommendation :: AnsiDoc -> AnsiDoc styleRecommendation = bold . green -- | Style an 'AnsiDoc' in a way that emphasizes that it is related to -- a current thing. For example, could be used when talking about the -- current package we're processing when outputting the name of it. styleCurrent :: AnsiDoc -> AnsiDoc styleCurrent = dullyellow -- TODO: figure out how to describe this styleTarget :: AnsiDoc -> AnsiDoc styleTarget = cyan -- | Style an 'AnsiDoc' as a module name styleModule :: AnsiDoc -> AnsiDoc styleModule = magenta -- TODO: what color should this be? instance Display PackageName where display = fromString . packageNameString instance Display PackageIdentifier where display = fromString . packageIdentifierString instance Display Version where display = fromString . versionString instance Display (Path b File) where display = styleFile . fromString . toFilePath instance Display (Path b Dir) where display = styleDir . fromString . toFilePath instance Display (PackageName, NamedComponent) where display = cyan . fromString . T.unpack . renderPkgComponent instance Display C.ModuleName where display = fromString . C.display -- Display milliseconds. displayMilliseconds :: Double -> AnsiDoc displayMilliseconds t = green $ fromString (show (round (t * 1000) :: Int)) <> "ms" -- | Display a bulleted list of 'AnsiDoc'. bulletedList :: [AnsiDoc] -> AnsiDoc bulletedList = mconcat . intersperse line . map (("*" <+>) . align) -- | Display a bulleted list of 'AnsiDoc' with a blank line between -- each. spacedBulletedList :: [AnsiDoc] -> AnsiDoc spacedBulletedList = mconcat . intersperse (line <> line) . map (("*" <+>) . align) stack-1.9.3.1/src/Stack/Runners.hs0000644000000000000000000002254113455617610015016 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude #-} {-# LANGUAGE DataKinds #-} {-# LANGUAGE FlexibleContexts #-} {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE RecordWildCards #-} {-# LANGUAGE TemplateHaskell #-} -- | Utilities for running stack commands. module Stack.Runners ( withGlobalConfigAndLock , withConfigAndLock , withMiniConfigAndLock , withBuildConfigAndLock , withBuildConfigAndLockNoDocker , withBuildConfig , withBuildConfigExt , withBuildConfigDot , loadConfigWithOpts , loadCompilerVersion , withUserFileLock , munlockFile ) where import Stack.Prelude import Path import Path.IO import Stack.Config import qualified Stack.Docker as Docker import qualified Stack.Nix as Nix import Stack.Setup import Stack.Types.Compiler (CompilerVersion, CVType (..)) import Stack.Types.Config import Stack.Types.Runner import System.Environment (getEnvironment) import System.IO import System.FileLock import Stack.Dot -- FIXME it seems wrong that we call lcLoadBuildConfig multiple times loadCompilerVersion :: GlobalOpts -> LoadConfig -> IO (CompilerVersion 'CVWanted) loadCompilerVersion go lc = view wantedCompilerVersionL <$> lcLoadBuildConfig lc (globalCompiler go) -- | Enforce mutual exclusion of every action running via this -- function, on this path, on this users account. -- -- A lock file is created inside the given directory. Currently, -- stack uses locks per-snapshot. In the future, stack may refine -- this to an even more fine-grain locking approach. -- withUserFileLock :: MonadUnliftIO m => GlobalOpts -> Path Abs Dir -> (Maybe FileLock -> m a) -> m a withUserFileLock go@GlobalOpts{} dir act = do env <- liftIO getEnvironment let toLock = lookup "STACK_LOCK" env == Just "true" if toLock then do let lockfile = $(mkRelFile "lockfile") let pth = dir lockfile ensureDir dir -- Just in case of asynchronous exceptions, we need to be careful -- when using tryLockFile here: bracket (liftIO $ tryLockFile (toFilePath pth) Exclusive) (maybe (return ()) (liftIO . unlockFile)) (\fstTry -> case fstTry of Just lk -> finally (act $ Just lk) (liftIO $ unlockFile lk) Nothing -> do let chatter = globalLogLevel go /= LevelOther "silent" when chatter $ liftIO $ hPutStrLn stderr $ "Failed to grab lock ("++show pth++ "); other stack instance running. Waiting..." bracket (liftIO $ lockFile (toFilePath pth) Exclusive) (liftIO . unlockFile) (\lk -> do when chatter $ liftIO $ hPutStrLn stderr "Lock acquired, proceeding." act $ Just lk)) else act Nothing withConfigAndLock :: GlobalOpts -> RIO Config () -> IO () withConfigAndLock go@GlobalOpts{..} inner = loadConfigWithOpts go $ \lc -> do withUserFileLock go (view stackRootL lc) $ \lk -> runRIO (lcConfig lc) $ Docker.reexecWithOptionalContainer (lcProjectRoot lc) Nothing (runRIO (lcConfig lc) inner) Nothing (Just $ munlockFile lk) -- | Loads global config, ignoring any configuration which would be -- loaded due to $PWD. withGlobalConfigAndLock :: GlobalOpts -> RIO Config () -> IO () withGlobalConfigAndLock go@GlobalOpts{..} inner = withRunnerGlobal go $ \runner -> do lc <- runRIO runner $ loadConfigMaybeProject globalConfigMonoid Nothing LCSNoProject withUserFileLock go (view stackRootL lc) $ \_lk -> runRIO (lcConfig lc) inner -- For now the non-locking version just unlocks immediately. -- That is, there's still a serialization point. withBuildConfig :: GlobalOpts -> RIO EnvConfig () -> IO () withBuildConfig go inner = withBuildConfigAndLock go (\lk -> do munlockFile lk inner) withBuildConfigAndLock :: GlobalOpts -> (Maybe FileLock -> RIO EnvConfig ()) -> IO () withBuildConfigAndLock go inner = withBuildConfigExt False go Nothing inner Nothing -- | See issue #2010 for why this exists. Currently just used for the -- specific case of "stack clean --full". withBuildConfigAndLockNoDocker :: GlobalOpts -> (Maybe FileLock -> RIO EnvConfig ()) -> IO () withBuildConfigAndLockNoDocker go inner = withBuildConfigExt True go Nothing inner Nothing withBuildConfigExt :: Bool -> GlobalOpts -> Maybe (RIO Config ()) -- ^ Action to perform before the build. This will be run on the host -- OS even if Docker is enabled for builds. The build config is not -- available in this action, since that would require build tools to be -- installed on the host OS. -> (Maybe FileLock -> RIO EnvConfig ()) -- ^ Action that uses the build config. If Docker is enabled for builds, -- this will be run in a Docker container. -> Maybe (RIO Config ()) -- ^ Action to perform after the build. This will be run on the host -- OS even if Docker is enabled for builds. The build config is not -- available in this action, since that would require build tools to be -- installed on the host OS. -> IO () withBuildConfigExt skipDocker go@GlobalOpts{..} mbefore inner mafter = loadConfigWithOpts go $ \lc -> do withUserFileLock go (view stackRootL lc) $ \lk0 -> do -- A local bit of state for communication between callbacks: curLk <- newIORef lk0 let inner' lk = -- Locking policy: This is only used for build commands, which -- only need to lock the snapshot, not the global lock. We -- trade in the lock here. do dir <- installationRootDeps -- Hand-over-hand locking: withUserFileLock go dir $ \lk2 -> do liftIO $ writeIORef curLk lk2 liftIO $ munlockFile lk logDebug "Starting to execute command inside EnvConfig" inner lk2 let inner'' lk = do bconfig <- lcLoadBuildConfig lc globalCompiler envConfig <- runRIO bconfig (setupEnv Nothing) runRIO envConfig (inner' lk) let getCompilerVersion = loadCompilerVersion go lc if skipDocker then runRIO (lcConfig lc) $ do forM_ mbefore id Nix.reexecWithOptionalShell (lcProjectRoot lc) getCompilerVersion (inner'' lk0) forM_ mafter id else runRIO (lcConfig lc) $ Docker.reexecWithOptionalContainer (lcProjectRoot lc) mbefore (runRIO (lcConfig lc) $ Nix.reexecWithOptionalShell (lcProjectRoot lc) getCompilerVersion (inner'' lk0)) mafter (Just $ liftIO $ do lk' <- readIORef curLk munlockFile lk') -- | Load the configuration. Convenience function used -- throughout this module. loadConfigWithOpts :: GlobalOpts -> (LoadConfig -> IO a) -> IO a loadConfigWithOpts go@GlobalOpts{..} inner = withRunnerGlobal go $ \runner -> do mstackYaml <- forM globalStackYaml resolveFile' runRIO runner $ do lc <- loadConfig globalConfigMonoid globalResolver mstackYaml -- If we have been relaunched in a Docker container, perform in-container initialization -- (switch UID, etc.). We do this after first loading the configuration since it must -- happen ASAP but needs a configuration. forM_ globalDockerEntrypoint $ Docker.entrypoint (lcConfig lc) liftIO $ inner lc withRunnerGlobal :: GlobalOpts -> (Runner -> IO a) -> IO a withRunnerGlobal GlobalOpts{..} = withRunner globalLogLevel globalTimeInLog globalTerminal globalColorWhen globalTermWidth (isJust globalReExecVersion) withMiniConfigAndLock :: GlobalOpts -> RIO MiniConfig () -> IO () withMiniConfigAndLock go@GlobalOpts{..} inner = withRunnerGlobal go $ \runner -> do miniConfig <- runRIO runner $ loadMiniConfig . lcConfig <$> loadConfigMaybeProject globalConfigMonoid globalResolver LCSNoProject runRIO miniConfig inner -- | Unlock a lock file, if the value is Just munlockFile :: MonadIO m => Maybe FileLock -> m () munlockFile Nothing = return () munlockFile (Just lk) = liftIO $ unlockFile lk -- Plumbing for --test and --bench flags withBuildConfigDot :: DotOpts -> GlobalOpts -> RIO EnvConfig () -> IO () withBuildConfigDot opts go f = withBuildConfig go' f where go' = (if dotTestTargets opts then set (globalOptsBuildOptsMonoidL.buildOptsMonoidTestsL) (Just True) else id) $ (if dotBenchTargets opts then set (globalOptsBuildOptsMonoidL.buildOptsMonoidBenchmarksL) (Just True) else id) go stack-1.9.3.1/src/Stack/Script.hs0000644000000000000000000002372013455617610014626 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude #-} {-# LANGUAGE CPP #-} {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TemplateHaskell #-} {-# LANGUAGE TupleSections #-} module Stack.Script ( scriptCmd ) where import Stack.Prelude import qualified Data.ByteString.Char8 as S8 import qualified Data.Conduit.List as CL import Data.List.Split (splitWhen) import qualified Data.Map.Strict as Map import qualified Data.Set as Set import Path import Path.IO import qualified Stack.Build import Stack.Constants (osIsWindows) import Stack.GhcPkg (ghcPkgExeName) import Stack.Options.ScriptParser import Stack.Runners import Stack.Types.BuildPlan import Stack.Types.Compiler import Stack.Types.Config import Stack.Types.PackageName import System.FilePath (dropExtension, replaceExtension) import RIO.Process -- | Run a Stack Script scriptCmd :: ScriptOpts -> GlobalOpts -> IO () scriptCmd opts go' = do file <- resolveFile' $ soFile opts let go = go' { globalConfigMonoid = (globalConfigMonoid go') { configMonoidInstallGHC = First $ Just True } , globalStackYaml = SYLNoConfig $ parent file } withBuildConfigAndLock go $ \lk -> do -- Some warnings in case the user somehow tries to set a -- stack.yaml location. Note that in this functions we use -- logError instead of logWarn because, when using the -- interpreter mode, only error messages are shown. See: -- https://github.com/commercialhaskell/stack/issues/3007 case globalStackYaml go' of SYLOverride fp -> logError $ "Ignoring override stack.yaml file for script command: " <> fromString fp SYLDefault -> return () SYLNoConfig _ -> assert False (return ()) config <- view configL menv <- liftIO $ configProcessContextSettings config defaultEnvSettings withProcessContext menv $ do wc <- view $ actualCompilerVersionL.whichCompilerL colorFlag <- appropriateGhcColorFlag targetsSet <- case soPackages opts of [] -> do -- Using the import parser moduleInfo <- view $ loadedSnapshotL.to toModuleInfo getPackagesFromModuleInfo moduleInfo (soFile opts) packages -> do let targets = concatMap wordsComma packages targets' <- mapM parsePackageNameFromString targets return $ Set.fromList targets' unless (Set.null targetsSet) $ do -- Optimization: use the relatively cheap ghc-pkg list -- --simple-output to check which packages are installed -- already. If all needed packages are available, we can -- skip the (rather expensive) build call below. bss <- sinkProcessStdout (ghcPkgExeName wc) ["list", "--simple-output"] CL.consume -- FIXME use the package info from envConfigPackages, or is that crazy? let installed = Set.fromList $ map toPackageName $ words $ S8.unpack $ S8.concat bss if Set.null $ Set.difference (Set.map packageNameString targetsSet) installed then logDebug "All packages already installed" else do logDebug "Missing packages, performing installation" Stack.Build.build (const $ return ()) lk defaultBuildOptsCLI { boptsCLITargets = map packageNameText $ Set.toList targetsSet } let ghcArgs = concat [ ["-hide-all-packages"] , maybeToList colorFlag , map (\x -> "-package" ++ x) $ Set.toList $ Set.insert "base" $ Set.map packageNameString targetsSet , case soCompile opts of SEInterpret -> [] SECompile -> [] SEOptimize -> ["-O2"] , map (\x -> "--ghc-arg=" ++ x) (soGhcOptions opts) ] munlockFile lk -- Unlock before transferring control away. case soCompile opts of SEInterpret -> exec ("run" ++ compilerExeName wc) (ghcArgs ++ toFilePath file : soArgs opts) _ -> do let dir = parent file -- Use readProcessStdout_ so that (1) if GHC does send any output -- to stdout, we capture it and stop it from being sent to our -- stdout, which could break scripts, and (2) if there's an -- exception, the standard output we did capture will be reported -- to the user. withWorkingDir (toFilePath dir) $ proc (compilerExeName wc) (ghcArgs ++ [toFilePath file]) (void . readProcessStdout_) exec (toExeName $ toFilePath file) (soArgs opts) where toPackageName = reverse . drop 1 . dropWhile (/= '-') . reverse -- Like words, but splits on both commas and spaces wordsComma = splitWhen (\c -> c == ' ' || c == ',') toExeName fp = if osIsWindows then replaceExtension fp "exe" else dropExtension fp getPackagesFromModuleInfo :: ModuleInfo -> FilePath -- ^ script filename -> RIO EnvConfig (Set PackageName) getPackagesFromModuleInfo mi scriptFP = do (pns1, mns) <- liftIO $ parseImports <$> S8.readFile scriptFP pns2 <- if Set.null mns then return Set.empty else do pns <- forM (Set.toList mns) $ \mn -> case Map.lookup mn $ miModules mi of Just pns -> case Set.toList pns of [] -> assert False $ return Set.empty [pn] -> return $ Set.singleton pn pns' -> throwString $ concat [ "Module " , S8.unpack $ unModuleName mn , " appears in multiple packages: " , unwords $ map packageNameString pns' ] Nothing -> return Set.empty return $ Set.unions pns `Set.difference` blacklist return $ Set.union pns1 pns2 -- | The Stackage project introduced the concept of hidden packages, -- to deal with conflicting module names. However, this is a -- relatively recent addition (at time of writing). See: -- http://www.snoyman.com/blog/2017/01/conflicting-module-names. To -- kick this thing off a bit better, we're included a blacklist of -- packages that should never be auto-parsed in. blacklist :: Set PackageName blacklist = Set.fromList [ $(mkPackageName "async-dejafu") , $(mkPackageName "monads-tf") , $(mkPackageName "crypto-api") , $(mkPackageName "fay-base") , $(mkPackageName "hashmap") , $(mkPackageName "hxt-unicode") , $(mkPackageName "hledger-web") , $(mkPackageName "plot-gtk3") , $(mkPackageName "gtk3") , $(mkPackageName "regex-pcre-builtin") , $(mkPackageName "regex-compat-tdfa") , $(mkPackageName "log") , $(mkPackageName "zip") , $(mkPackageName "monad-extras") , $(mkPackageName "control-monad-free") , $(mkPackageName "prompt") , $(mkPackageName "kawhi") , $(mkPackageName "language-c") , $(mkPackageName "gl") , $(mkPackageName "svg-tree") , $(mkPackageName "Glob") , $(mkPackageName "nanospec") , $(mkPackageName "HTF") , $(mkPackageName "courier") , $(mkPackageName "newtype-generics") , $(mkPackageName "objective") , $(mkPackageName "binary-ieee754") , $(mkPackageName "rerebase") , $(mkPackageName "cipher-aes") , $(mkPackageName "cipher-blowfish") , $(mkPackageName "cipher-camellia") , $(mkPackageName "cipher-des") , $(mkPackageName "cipher-rc4") , $(mkPackageName "crypto-cipher-types") , $(mkPackageName "crypto-numbers") , $(mkPackageName "crypto-pubkey") , $(mkPackageName "crypto-random") , $(mkPackageName "cryptohash") , $(mkPackageName "cryptohash-conduit") , $(mkPackageName "cryptohash-md5") , $(mkPackageName "cryptohash-sha1") , $(mkPackageName "cryptohash-sha256") ] toModuleInfo :: LoadedSnapshot -> ModuleInfo toModuleInfo ls = mconcat $ map (\(pn, lpi) -> ModuleInfo $ Map.fromList $ map (, Set.singleton pn) $ Set.toList $ lpiExposedModules lpi) $ filter (\(pn, lpi) -> not (lpiHide lpi) && pn `Set.notMember` blacklist) $ Map.toList $ Map.union (void <$> lsPackages ls) (void <$> lsGlobals ls) parseImports :: ByteString -> (Set PackageName, Set ModuleName) parseImports = fold . mapMaybe (parseLine . stripCR') . S8.lines where -- Remove any carriage return character present at the end, to -- support Windows-style line endings (CRLF) stripCR' bs | S8.null bs = bs | S8.last bs == '\r' = S8.init bs | otherwise = bs stripPrefix x y | x `S8.isPrefixOf` y = Just $ S8.drop (S8.length x) y | otherwise = Nothing parseLine bs0 = do bs1 <- stripPrefix "import " bs0 let bs2 = S8.dropWhile (== ' ') bs1 bs3 = fromMaybe bs2 $ stripPrefix "qualified " bs2 case stripPrefix "\"" bs3 of Just bs4 -> do pn <- parsePackageNameFromString $ S8.unpack $ S8.takeWhile (/= '"') bs4 Just (Set.singleton pn, Set.empty) Nothing -> Just ( Set.empty , Set.singleton $ ModuleName $ S8.takeWhile (\c -> c /= ' ' && c /= '(') bs3 ) stack-1.9.3.1/src/Stack/SDist.hs0000644000000000000000000005670613455671116014423 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude #-} {-# LANGUAGE ConstraintKinds #-} {-# LANGUAGE FlexibleContexts #-} {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE RankNTypes #-} {-# LANGUAGE DeriveDataTypeable #-} {-# LANGUAGE TypeFamilies #-} -- Create a source distribution tarball module Stack.SDist ( getSDistTarball , checkSDistTarball , checkSDistTarball' , SDistOpts (..) ) where import qualified Codec.Archive.Tar as Tar import qualified Codec.Archive.Tar.Entry as Tar import qualified Codec.Compression.GZip as GZip import Control.Applicative import Control.Concurrent.Execute (ActionContext(..), Concurrency(..)) import Stack.Prelude hiding (Display (..)) import Control.Monad.Reader.Class (local) import qualified Data.ByteString as S import qualified Data.ByteString.Char8 as S8 import qualified Data.ByteString.Lazy as L import Data.Char (toLower) import Data.Data (cast) import Data.List import Data.List.NonEmpty (NonEmpty) import qualified Data.List.NonEmpty as NE import qualified Data.Map.Strict as Map import qualified Data.Set as Set import qualified Data.Text as T import qualified Data.Text.Encoding as T import qualified Data.Text.Encoding.Error as T import qualified Data.Text.Lazy as TL import qualified Data.Text.Lazy.Encoding as TLE import Data.Time.Clock.POSIX import Distribution.Package (Dependency (..)) import qualified Distribution.PackageDescription as Cabal import qualified Distribution.PackageDescription.Check as Check import qualified Distribution.PackageDescription.Parsec as Cabal import Distribution.PackageDescription.PrettyPrint (showGenericPackageDescription) import qualified Distribution.Types.UnqualComponentName as Cabal import qualified Distribution.Text as Cabal import Distribution.Version (simplifyVersionRange, orLaterVersion, earlierVersion, hasUpperBound, hasLowerBound) import Lens.Micro (set) import Path import Path.IO hiding (getModificationTime, getPermissions, withSystemTempDir) import qualified RIO import Stack.Build (mkBaseConfigOpts, build) import Stack.Build.Execute import Stack.Build.Installed import Stack.Build.Source (loadSourceMap) import Stack.Build.Target hiding (PackageType (..)) import Stack.PackageLocation (resolveMultiPackageLocation) import Stack.PrettyPrint import Stack.Constants import Stack.Package import Stack.Types.Build import Stack.Types.BuildPlan import Stack.Types.Config import Stack.Types.Package import Stack.Types.PackageIdentifier import Stack.Types.PackageName import Stack.Types.Runner import Stack.Types.Version import System.Directory (getModificationTime, getPermissions) import qualified System.FilePath as FP -- | Special exception to throw when you want to fail because of bad results -- of package check. data SDistOpts = SDistOpts { sdoptsDirsToWorkWith :: [String] -- ^ Directories to package , sdoptsPvpBounds :: Maybe PvpBounds -- ^ PVP Bounds overrides , sdoptsIgnoreCheck :: Bool -- ^ Whether to ignore check of the package for common errors , sdoptsSign :: Bool -- ^ Whether to sign the package , sdoptsSignServerUrl :: String -- ^ The URL of the signature server , sdoptsBuildTarball :: Bool -- ^ Whether to build the tarball , sdoptsTarPath :: Maybe FilePath -- ^ Where to copy the tarball } newtype CheckException = CheckException (NonEmpty Check.PackageCheck) deriving (Typeable) instance Exception CheckException instance Show CheckException where show (CheckException xs) = "Package check reported the following errors:\n" ++ (intercalate "\n" . fmap show . NE.toList $ xs) -- | Given the path to a local package, creates its source -- distribution tarball. -- -- While this yields a 'FilePath', the name of the tarball, this -- tarball is not written to the disk and instead yielded as a lazy -- bytestring. getSDistTarball :: HasEnvConfig env => Maybe PvpBounds -- ^ Override Config value -> Path Abs Dir -- ^ Path to local package -> RIO env (FilePath, L.ByteString, Maybe (PackageIdentifier, L.ByteString)) -- ^ Filename, tarball contents, and option cabal file revision to upload getSDistTarball mpvpBounds pkgDir = do config <- view configL let PvpBounds pvpBounds asRevision = fromMaybe (configPvpBounds config) mpvpBounds tweakCabal = pvpBounds /= PvpBoundsNone pkgFp = toFilePath pkgDir lp <- readLocalPackage pkgDir logInfo $ "Getting file list for " <> fromString pkgFp (fileList, cabalfp) <- getSDistFileList lp logInfo $ "Building sdist tarball for " <> fromString pkgFp files <- normalizeTarballPaths (map (T.unpack . stripCR . T.pack) (lines fileList)) -- We're going to loop below and eventually find the cabal -- file. When we do, we'll upload this reference, if the -- mpvpBounds value indicates that we should be uploading a cabal -- file revision. cabalFileRevisionRef <- liftIO (newIORef Nothing) -- NOTE: Could make this use lazy I/O to only read files as needed -- for upload (both GZip.compress and Tar.write are lazy). -- However, it seems less error prone and more predictable to read -- everything in at once, so that's what we're doing for now: let tarPath isDir fp = either throwString return (Tar.toTarPath isDir (forceUtf8Enc (pkgId FP. fp))) -- convert a String of proper characters to a String of bytes -- in UTF8 encoding masquerading as characters. This is -- necessary for tricking the tar package into proper -- character encoding. forceUtf8Enc = S8.unpack . T.encodeUtf8 . T.pack packWith f isDir fp = liftIO $ f (pkgFp FP. fp) =<< tarPath isDir fp packDir = packWith Tar.packDirectoryEntry True packFile fp -- This is a cabal file, we're going to tweak it, but only -- tweak it as a revision. | tweakCabal && isCabalFp fp && asRevision = do lbsIdent <- getCabalLbs pvpBounds (Just 1) cabalfp liftIO (writeIORef cabalFileRevisionRef (Just lbsIdent)) packWith packFileEntry False fp -- Same, except we'll include the cabal file in the -- original tarball upload. | tweakCabal && isCabalFp fp = do (_ident, lbs) <- getCabalLbs pvpBounds Nothing cabalfp currTime <- liftIO getPOSIXTime -- Seconds from UNIX epoch tp <- liftIO $ tarPath False fp return $ (Tar.fileEntry tp lbs) { Tar.entryTime = floor currTime } | otherwise = packWith packFileEntry False fp isCabalFp fp = toFilePath pkgDir FP. fp == toFilePath cabalfp tarName = pkgId FP.<.> "tar.gz" pkgId = packageIdentifierString (packageIdentifier (lpPackage lp)) dirEntries <- mapM packDir (dirsFromFiles files) fileEntries <- mapM packFile files mcabalFileRevision <- liftIO (readIORef cabalFileRevisionRef) return (tarName, GZip.compress (Tar.write (dirEntries ++ fileEntries)), mcabalFileRevision) -- | Get the PVP bounds-enabled version of the given cabal file getCabalLbs :: HasEnvConfig env => PvpBoundsType -> Maybe Int -- ^ optional revision -> Path Abs File -- ^ cabal file -> RIO env (PackageIdentifier, L.ByteString) getCabalLbs pvpBounds mrev cabalfp = do (gpd, cabalfp') <- readPackageUnresolvedDir (parent cabalfp) False unless (cabalfp == cabalfp') $ error $ "getCabalLbs: cabalfp /= cabalfp': " ++ show (cabalfp, cabalfp') (_, sourceMap) <- loadSourceMap AllowNoTargets defaultBuildOptsCLI (installedMap, _, _, _) <- getInstalled GetInstalledOpts { getInstalledProfiling = False , getInstalledHaddock = False , getInstalledSymbols = False } sourceMap let internalPackages = Set.fromList $ gpdPackageName gpd : map (fromCabalPackageName . Cabal.unqualComponentNameToPackageName . fst) (Cabal.condSubLibraries gpd) gpd' = gtraverseT (addBounds internalPackages sourceMap installedMap) gpd gpd'' = case mrev of Nothing -> gpd' Just rev -> gpd' { Cabal.packageDescription = (Cabal.packageDescription gpd') { Cabal.customFieldsPD = (("x-revision", show rev):) $ filter (\(x, _) -> map toLower x /= "x-revision") $ Cabal.customFieldsPD $ Cabal.packageDescription gpd' } } ident <- parsePackageIdentifierFromString $ Cabal.display $ Cabal.package $ Cabal.packageDescription gpd'' -- Sanity rendering and reparsing the input, to ensure there are no -- cabal bugs, since there have been bugs here before, and currently -- are at the time of writing: -- -- https://github.com/haskell/cabal/issues/1202 -- https://github.com/haskell/cabal/issues/2353 -- https://github.com/haskell/cabal/issues/4863 (current issue) let roundtripErrs = [ flow "Bug detected in Cabal library. ((parse . render . parse) === id) does not hold for the cabal file at" <+> display cabalfp , "" ] (_warnings, eres) = Cabal.runParseResult $ Cabal.parseGenericPackageDescription $ T.encodeUtf8 $ T.pack $ showGenericPackageDescription gpd case eres of Right roundtripped | roundtripped == gpd -> return () | otherwise -> do prettyWarn $ vsep $ roundtripErrs ++ [ "This seems to be fixed in development versions of Cabal, but at time of writing, the fix is not in any released versions." , "" , "Please see this GitHub issue for status:" <+> styleUrl "https://github.com/commercialhaskell/stack/issues/3549" , "" , fillSep [ flow "If the issue is closed as resolved, then you may be able to fix this by upgrading to a newer version of stack via" , styleShell "stack upgrade" , flow "for latest stable version or" , styleShell "stack upgrade --git" , flow "for the latest development version." ] , "" , fillSep [ flow "If the issue is fixed, but updating doesn't solve the problem, please check if there are similar open issues, and if not, report a new issue to the stack issue tracker, at" , styleUrl "https://github.com/commercialhaskell/stack/issues/new" ] , "" , flow "If the issue is not fixed, feel free to leave a comment on it indicating that you would like it to be fixed." , "" ] Left (_version, errs) -> do prettyWarn $ vsep $ roundtripErrs ++ [ flow "In particular, parsing the rendered cabal file is yielding a parse error. Please check if there are already issues tracking this, and if not, please report new issues to the stack and cabal issue trackers, via" , bulletedList [ styleUrl "https://github.com/commercialhaskell/stack/issues/new" , styleUrl "https://github.com/haskell/cabal/issues/new" ] , flow $ "The parse error is: " ++ unlines (map show errs) , "" ] return ( ident , TLE.encodeUtf8 $ TL.pack $ showGenericPackageDescription gpd'' ) where addBounds :: Set PackageName -> SourceMap -> InstalledMap -> Dependency -> Dependency addBounds internalPackages sourceMap installedMap dep@(Dependency cname range) = if name `Set.member` internalPackages then dep else case foundVersion of Nothing -> dep Just version -> Dependency cname $ simplifyVersionRange $ (if toAddUpper && not (hasUpperBound range) then addUpper version else id) $ (if toAddLower && not (hasLowerBound range) then addLower version else id) range where name = fromCabalPackageName cname foundVersion = case Map.lookup name sourceMap of Just ps -> Just (piiVersion ps) Nothing -> case Map.lookup name installedMap of Just (_, installed) -> Just (installedVersion installed) Nothing -> Nothing addUpper version = intersectVersionRanges (earlierVersion $ toCabalVersion $ nextMajorVersion version) addLower version = intersectVersionRanges (orLaterVersion (toCabalVersion version)) (toAddLower, toAddUpper) = case pvpBounds of PvpBoundsNone -> (False, False) PvpBoundsUpper -> (False, True) PvpBoundsLower -> (True, False) PvpBoundsBoth -> (True, True) -- | Traverse a data type. gtraverseT :: (Data a,Typeable b) => (Typeable b => b -> b) -> a -> a gtraverseT f = gmapT (\x -> case cast x of Nothing -> gtraverseT f x Just b -> fromMaybe x (cast (f b))) -- | Read in a 'LocalPackage' config. This makes some default decisions -- about 'LocalPackage' fields that might not be appropriate for other -- use-cases. readLocalPackage :: HasEnvConfig env => Path Abs Dir -> RIO env LocalPackage readLocalPackage pkgDir = do config <- getDefaultPackageConfig (package, cabalfp) <- readPackageDir config pkgDir True return LocalPackage { lpPackage = package , lpWanted = False -- HACK: makes it so that sdist output goes to a log instead of a file. , lpDir = pkgDir , lpCabalFile = cabalfp -- NOTE: these aren't the 'correct values, but aren't used in -- the usage of this function in this module. , lpTestDeps = Map.empty , lpBenchDeps = Map.empty , lpTestBench = Nothing , lpForceDirty = False , lpDirtyFiles = Nothing , lpNewBuildCaches = Map.empty , lpComponentFiles = Map.empty , lpComponents = Set.empty , lpUnbuildable = Set.empty , lpLocation = PLFilePath $ toFilePath pkgDir } -- | Returns a newline-separate list of paths, and the absolute path to the .cabal file. getSDistFileList :: HasEnvConfig env => LocalPackage -> RIO env (String, Path Abs File) getSDistFileList lp = withSystemTempDir (stackProgName <> "-sdist") $ \tmpdir -> do let bopts = defaultBuildOpts let boptsCli = defaultBuildOptsCLI baseConfigOpts <- mkBaseConfigOpts boptsCli (locals, _) <- loadSourceMap NeedTargets boptsCli withExecuteEnv bopts boptsCli baseConfigOpts locals [] [] [] -- provide empty list of globals. This is a hack around custom Setup.hs files $ \ee -> withSingleContext ac ee task Nothing (Just "sdist") $ \_package cabalfp _pkgDir cabal _announce _outputType -> do let outFile = toFilePath tmpdir FP. "source-files-list" cabal KeepTHLoading ["sdist", "--list-sources", outFile] contents <- liftIO (S.readFile outFile) return (T.unpack $ T.decodeUtf8With T.lenientDecode contents, cabalfp) where package = lpPackage lp ac = ActionContext Set.empty [] ConcurrencyAllowed task = Task { taskProvides = PackageIdentifier (packageName package) (packageVersion package) , taskType = TTFiles lp Local , taskConfigOpts = TaskConfigOpts { tcoMissing = Set.empty , tcoOpts = \_ -> ConfigureOpts [] [] } , taskPresent = Map.empty , taskAllInOne = True , taskCachePkgSrc = CacheSrcLocal (toFilePath (lpDir lp)) , taskAnyMissing = True , taskBuildTypeConfig = False } normalizeTarballPaths :: HasRunner env => [FilePath] -> RIO env [FilePath] normalizeTarballPaths fps = do -- TODO: consider whether erroring out is better - otherwise the -- user might upload an incomplete tar? unless (null outsideDir) $ logWarn $ "Warning: These files are outside of the package directory, and will be omitted from the tarball: " <> displayShow outsideDir return (nubOrd files) where (outsideDir, files) = partitionEithers (map pathToEither fps) pathToEither fp = maybe (Left fp) Right (normalizePath fp) normalizePath :: FilePath -> Maybe FilePath normalizePath = fmap FP.joinPath . go . FP.splitDirectories . FP.normalise where go [] = Just [] go ("..":_) = Nothing go (_:"..":xs) = go xs go (x:xs) = (x :) <$> go xs dirsFromFiles :: [FilePath] -> [FilePath] dirsFromFiles dirs = Set.toAscList (Set.delete "." results) where results = foldl' (\s -> go s . FP.takeDirectory) Set.empty dirs go s x | Set.member x s = s | otherwise = go (Set.insert x s) (FP.takeDirectory x) -- | Check package in given tarball. This will log all warnings -- and will throw an exception in case of critical errors. -- -- Note that we temporarily decompress the archive to analyze it. checkSDistTarball :: HasEnvConfig env => SDistOpts -- ^ The configuration of what to check -> Path Abs File -- ^ Absolute path to tarball -> RIO env () checkSDistTarball opts tarball = withTempTarGzContents tarball $ \pkgDir' -> do pkgDir <- (pkgDir' ) `liftM` (parseRelDir . FP.takeBaseName . FP.takeBaseName . toFilePath $ tarball) -- ^ drop ".tar" ^ drop ".gz" when (sdoptsBuildTarball opts) (buildExtractedTarball pkgDir) unless (sdoptsIgnoreCheck opts) (checkPackageInExtractedTarball pkgDir) checkPackageInExtractedTarball :: HasEnvConfig env => Path Abs Dir -- ^ Absolute path to tarball -> RIO env () checkPackageInExtractedTarball pkgDir = do (gpd, _cabalfp) <- readPackageUnresolvedDir pkgDir True let name = gpdPackageName gpd config <- getDefaultPackageConfig (gdesc, PackageDescriptionPair pkgDesc _) <- readPackageDescriptionDir config pkgDir False logInfo $ "Checking package '" <> RIO.display name <> "' for common mistakes" let pkgChecks = -- MSS 2017-12-12: Try out a few different variants of -- pkgDesc to try and provoke an error or warning. I don't -- know why, but when using `Just pkgDesc`, it appears that -- Cabal does not detect that `^>=` is used with -- `cabal-version: 1.24` or earlier. It seems like pkgDesc -- (the one we create) does not populate the `buildDepends` -- field, whereas flattenPackageDescription from Cabal -- does. In any event, using `Nothing` seems more logical -- for this check anyway, and the fallback to `Just pkgDesc` -- is just a crazy sanity check. case Check.checkPackage gdesc Nothing of [] -> Check.checkPackage gdesc (Just pkgDesc) x -> x fileChecks <- liftIO $ Check.checkPackageFiles minBound pkgDesc (toFilePath pkgDir) let checks = pkgChecks ++ fileChecks (errors, warnings) = let criticalIssue (Check.PackageBuildImpossible _) = True criticalIssue (Check.PackageDistInexcusable _) = True criticalIssue _ = False in partition criticalIssue checks unless (null warnings) $ logWarn $ "Package check reported the following warnings:\n" <> mconcat (intersperse "\n" . fmap displayShow $ warnings) case NE.nonEmpty errors of Nothing -> return () Just ne -> throwM $ CheckException ne buildExtractedTarball :: HasEnvConfig env => Path Abs Dir -> RIO env () buildExtractedTarball pkgDir = do projectRoot <- view projectRootL envConfig <- view envConfigL localPackageToBuild <- readLocalPackage pkgDir let packageEntries = bcPackages (envConfigBuildConfig envConfig) getPaths = resolveMultiPackageLocation projectRoot allPackagePaths <- fmap (map fst . mconcat) (mapM getPaths packageEntries) -- We remove the path based on the name of the package let isPathToRemove path = do localPackage <- readLocalPackage path return $ packageName (lpPackage localPackage) == packageName (lpPackage localPackageToBuild) pathsToKeep <- filterM (fmap not . isPathToRemove) allPackagePaths newPackagesRef <- liftIO (newIORef Nothing) let adjustEnvForBuild env = let updatedEnvConfig = envConfig {envConfigPackagesRef = newPackagesRef ,envConfigBuildConfig = updatePackageInBuildConfig (envConfigBuildConfig envConfig) } in set envConfigL updatedEnvConfig env updatePackageInBuildConfig buildConfig = buildConfig { bcPackages = map (PLFilePath . toFilePath) $ pkgDir : pathsToKeep , bcConfig = (bcConfig buildConfig) { configBuild = defaultBuildOpts { boptsTests = True } } } local adjustEnvForBuild $ build (const (return ())) Nothing defaultBuildOptsCLI -- | Version of 'checkSDistTarball' that first saves lazy bytestring to -- temporary directory and then calls 'checkSDistTarball' on it. checkSDistTarball' :: HasEnvConfig env => SDistOpts -> String -- ^ Tarball name -> L.ByteString -- ^ Tarball contents as a byte string -> RIO env () checkSDistTarball' opts name bytes = withSystemTempDir "stack" $ \tpath -> do npath <- (tpath ) `liftM` parseRelFile name liftIO $ L.writeFile (toFilePath npath) bytes checkSDistTarball opts npath withTempTarGzContents :: Path Abs File -- ^ Location of tarball -> (Path Abs Dir -> RIO env a) -- ^ Perform actions given dir with tarball contents -> RIO env a withTempTarGzContents apath f = withSystemTempDir "stack" $ \tpath -> do archive <- liftIO $ L.readFile (toFilePath apath) liftIO . Tar.unpack (toFilePath tpath) . Tar.read . GZip.decompress $ archive f tpath -------------------------------------------------------------------------------- -- Copy+modified from the tar package to avoid issues with lazy IO ( see -- https://github.com/commercialhaskell/stack/issues/1344 ) packFileEntry :: FilePath -- ^ Full path to find the file on the local disk -> Tar.TarPath -- ^ Path to use for the tar Entry in the archive -> IO Tar.Entry packFileEntry filepath tarpath = do mtime <- getModTime filepath perms <- getPermissions filepath content <- S.readFile filepath let size = fromIntegral (S.length content) return (Tar.simpleEntry tarpath (Tar.NormalFile (L.fromStrict content) size)) { Tar.entryPermissions = if executable perms then Tar.executableFilePermissions else Tar.ordinaryFilePermissions, Tar.entryTime = mtime } getModTime :: FilePath -> IO Tar.EpochTime getModTime path = do t <- getModificationTime path return . floor . utcTimeToPOSIXSeconds $ t getDefaultPackageConfig :: (MonadIO m, MonadReader env m, HasEnvConfig env) => m PackageConfig getDefaultPackageConfig = do platform <- view platformL compilerVersion <- view actualCompilerVersionL return PackageConfig { packageConfigEnableTests = False , packageConfigEnableBenchmarks = False , packageConfigFlags = mempty , packageConfigGhcOptions = [] , packageConfigCompilerVersion = compilerVersion , packageConfigPlatform = platform } stack-1.9.3.1/src/Stack/Setup.hs0000644000000000000000000026505013455671116014467 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude #-} {-# LANGUAGE ConstraintKinds #-} {-# LANGUAGE DataKinds #-} {-# LANGUAGE DeriveDataTypeable #-} -- ghc < 7.10 {-# LANGUAGE DeriveFunctor #-} {-# LANGUAGE FlexibleContexts #-} {-# LANGUAGE LambdaCase #-} {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE PackageImports #-} {-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE TemplateHaskell #-} {-# LANGUAGE ViewPatterns #-} {-# LANGUAGE TypeFamilies #-} {-# LANGUAGE MultiWayIf #-} {-# LANGUAGE CPP #-} module Stack.Setup ( setupEnv , ensureCompiler , ensureDockerStackExe , getSystemCompiler , getCabalInstallVersion , SetupOpts (..) , defaultSetupInfoYaml , removeHaskellEnvVars -- * Stack binary download , StackReleaseInfo , getDownloadVersion , stackVersion , preferredPlatforms , downloadStackReleaseInfo , downloadStackExe ) where import qualified Codec.Archive.Tar as Tar import Control.Applicative (empty) import Control.Monad.State (get, put, modify) import "cryptonite" Crypto.Hash (SHA1(..), SHA256(..)) import Data.Aeson.Extended import qualified Data.ByteString as S import qualified Data.ByteString.Lazy as LBS import qualified Data.ByteString.Lazy.Char8 as BL8 import Data.Char (isSpace) import Data.Conduit (await, yield, awaitForever) import qualified Data.Conduit.Binary as CB import Data.Conduit.Lazy (lazyConsume) import Data.Conduit.Lift (evalStateC) import qualified Data.Conduit.List as CL import Data.Conduit.Process.Typed (eceStderr) import Data.Conduit.Zlib (ungzip) import Data.Foldable (maximumBy) import qualified Data.HashMap.Strict as HashMap import Data.IORef.RunOnce (runOnce) import Data.List hiding (concat, elem, maximumBy, any) import qualified Data.Map as Map import qualified Data.Set as Set import qualified Data.Text as T import qualified Data.Text.Encoding as T import qualified Data.Text.Encoding.Error as T import Data.Time.Clock (NominalDiffTime, diffUTCTime, getCurrentTime) import qualified Data.Yaml as Yaml import Distribution.System (OS, Arch (..), Platform (..)) import qualified Distribution.System as Cabal import Distribution.Text (simpleParse) import Lens.Micro (set) import Network.HTTP.StackClient (getResponseBody, getResponseStatusCode) import Network.HTTP.Download import Path import Path.CheckInstall (warnInstallSearchPathIssues) import Path.Extra (toFilePathNoTrailingSep) import Path.IO hiding (findExecutable, withSystemTempDir) import Prelude (until) import qualified RIO import Stack.Build (build) import Stack.Config (loadConfig) import Stack.Constants (stackProgName) import Stack.Constants.Config (distRelativeDir) import Stack.Fetch import Stack.GhcPkg (createDatabase, getCabalPkgVer, getGlobalDB, mkGhcPackagePath, ghcPkgPathEnvVar) import Stack.Prelude hiding (Display (..)) import Stack.PrettyPrint import Stack.Setup.Installed import Stack.Snapshot (loadSnapshot) import Stack.Types.Build import Stack.Types.Compiler import Stack.Types.CompilerBuild import Stack.Types.Config import Stack.Types.Docker import Stack.Types.PackageIdentifier import Stack.Types.PackageName import Stack.Types.Runner import Stack.Types.Version import qualified System.Directory as D import System.Environment (getExecutablePath, lookupEnv) import System.Exit (ExitCode (..), exitFailure) import System.IO.Error (isPermissionError) import System.FilePath (searchPathSeparator) import qualified System.FilePath as FP import RIO.Process import Text.Printf (printf) #if !WINDOWS import Bindings.Uname (uname, release) import Data.List.Split (splitOn) import Foreign.C (throwErrnoIfMinus1_, peekCString) import Foreign.Marshal (alloca) import System.Posix.Files (setFileMode) #endif -- | Default location of the stack-setup.yaml file defaultSetupInfoYaml :: String defaultSetupInfoYaml = "https://raw.githubusercontent.com/fpco/stackage-content/master/stack/stack-setup-2.yaml" data SetupOpts = SetupOpts { soptsInstallIfMissing :: !Bool , soptsUseSystem :: !Bool -- ^ Should we use a system compiler installation, if available? , soptsWantedCompiler :: !(CompilerVersion 'CVWanted) , soptsCompilerCheck :: !VersionCheck , soptsStackYaml :: !(Maybe (Path Abs File)) -- ^ If we got the desired GHC version from that file , soptsForceReinstall :: !Bool , soptsSanityCheck :: !Bool -- ^ Run a sanity check on the selected GHC , soptsSkipGhcCheck :: !Bool -- ^ Don't check for a compatible GHC version/architecture , soptsSkipMsys :: !Bool -- ^ Do not use a custom msys installation on Windows , soptsUpgradeCabal :: !(Maybe UpgradeTo) -- ^ Upgrade the global Cabal library in the database to the newest -- version. Only works reliably with a stack-managed installation. , soptsResolveMissingGHC :: !(Maybe Text) -- ^ Message shown to user for how to resolve the missing GHC , soptsSetupInfoYaml :: !FilePath -- ^ Location of the main stack-setup.yaml file , soptsGHCBindistURL :: !(Maybe String) -- ^ Alternate GHC binary distribution (requires custom GHCVariant) , soptsGHCJSBootOpts :: [String] -- ^ Additional ghcjs-boot options, the default is "--clean" } deriving Show data SetupException = UnsupportedSetupCombo OS Arch | MissingDependencies [String] | UnknownCompilerVersion (Set.Set Text) (CompilerVersion 'CVWanted) (Set.Set (CompilerVersion 'CVActual)) | UnknownOSKey Text | GHCSanityCheckCompileFailed SomeException (Path Abs File) | WantedMustBeGHC | RequireCustomGHCVariant | ProblemWhileDecompressing (Path Abs File) | SetupInfoMissingSevenz | GHCJSRequiresStandardVariant | GHCJSNotBooted | DockerStackExeNotFound Version Text | UnsupportedSetupConfiguration deriving Typeable instance Exception SetupException instance Show SetupException where show (UnsupportedSetupCombo os arch) = concat [ "I don't know how to install GHC for " , show (os, arch) , ", please install manually" ] show (MissingDependencies tools) = "The following executables are missing and must be installed: " ++ intercalate ", " tools show (UnknownCompilerVersion oskeys wanted known) = concat [ "No setup information found for " , compilerVersionString wanted , " on your platform.\nThis probably means a GHC bindist has not yet been added for OS key '" , T.unpack (T.intercalate "', '" (sort $ Set.toList oskeys)) , "'.\nSupported versions: " , T.unpack (T.intercalate ", " (map compilerVersionText (sort $ Set.toList known))) ] show (UnknownOSKey oskey) = "Unable to find installation URLs for OS key: " ++ T.unpack oskey show (GHCSanityCheckCompileFailed e ghc) = concat [ "The GHC located at " , toFilePath ghc , " failed to compile a sanity check. Please see:\n\n" , " http://docs.haskellstack.org/en/stable/install_and_upgrade/\n\n" , "for more information. Exception was:\n" , show e ] show WantedMustBeGHC = "The wanted compiler must be GHC" show RequireCustomGHCVariant = "A custom --ghc-variant must be specified to use --ghc-bindist" show (ProblemWhileDecompressing archive) = "Problem while decompressing " ++ toFilePath archive show SetupInfoMissingSevenz = "SetupInfo missing Sevenz EXE/DLL" show GHCJSRequiresStandardVariant = "stack does not yet support using --ghc-variant with GHCJS" show GHCJSNotBooted = "GHCJS does not yet have its boot packages installed. Use \"stack setup\" to attempt to run ghcjs-boot." show (DockerStackExeNotFound stackVersion' osKey) = concat [ stackProgName , "-" , versionString stackVersion' , " executable not found for " , T.unpack osKey , "\nUse the '" , T.unpack dockerStackExeArgName , "' option to specify a location"] show UnsupportedSetupConfiguration = "I don't know how to install GHC on your system configuration, please install manually" -- | Modify the environment variables (like PATH) appropriately, possibly doing installation too setupEnv :: (HasBuildConfig env, HasGHCVariant env) => Maybe Text -- ^ Message to give user when necessary GHC is not available -> RIO env EnvConfig setupEnv mResolveMissingGHC = do config <- view configL bconfig <- view buildConfigL let stackYaml = bcStackYaml bconfig platform <- view platformL wcVersion <- view wantedCompilerVersionL wc <- view $ wantedCompilerVersionL.whichCompilerL let sopts = SetupOpts { soptsInstallIfMissing = configInstallGHC config , soptsUseSystem = configSystemGHC config , soptsWantedCompiler = wcVersion , soptsCompilerCheck = configCompilerCheck config , soptsStackYaml = Just stackYaml , soptsForceReinstall = False , soptsSanityCheck = False , soptsSkipGhcCheck = configSkipGHCCheck config , soptsSkipMsys = configSkipMsys config , soptsUpgradeCabal = Nothing , soptsResolveMissingGHC = mResolveMissingGHC , soptsSetupInfoYaml = defaultSetupInfoYaml , soptsGHCBindistURL = Nothing , soptsGHCJSBootOpts = ["--clean"] } (mghcBin, compilerBuild, _) <- ensureCompiler sopts -- Modify the initial environment to include the GHC path, if a local GHC -- is being used menv0 <- view processContextL env <- either throwM (return . removeHaskellEnvVars) $ augmentPathMap (map toFilePath $ maybe [] edBins mghcBin) (view envVarsL menv0) menv <- mkProcessContext env (compilerVer, cabalVer, globaldb) <- withProcessContext menv $ runConcurrently $ (,,) <$> Concurrently (getCompilerVersion wc) <*> Concurrently (getCabalPkgVer wc) <*> Concurrently (getGlobalDB wc) logDebug "Resolving package entries" packagesRef <- liftIO $ newIORef Nothing bc <- view buildConfigL -- Set up a modified environment which includes the modified PATH -- that GHC can be found on. This is needed for looking up global -- package information in loadSnapshot. let bcPath :: BuildConfig bcPath = set processContextL menv bc ls <- runRIO bcPath $ loadSnapshot (Just compilerVer) (view projectRootL bc) (bcSnapshotDef bc) let envConfig0 = EnvConfig { envConfigBuildConfig = bc , envConfigCabalVersion = cabalVer , envConfigCompilerVersion = compilerVer , envConfigCompilerBuild = compilerBuild , envConfigPackagesRef = packagesRef , envConfigLoadedSnapshot = ls } -- extra installation bin directories mkDirs <- runReaderT extraBinDirs envConfig0 let mpath = Map.lookup "PATH" env depsPath <- either throwM return $ augmentPath (toFilePath <$> mkDirs False) mpath localsPath <- either throwM return $ augmentPath (toFilePath <$> mkDirs True) mpath deps <- runReaderT packageDatabaseDeps envConfig0 withProcessContext menv $ createDatabase wc deps localdb <- runReaderT packageDatabaseLocal envConfig0 withProcessContext menv $ createDatabase wc localdb extras <- runReaderT packageDatabaseExtra envConfig0 let mkGPP locals = mkGhcPackagePath locals localdb deps extras globaldb distDir <- runReaderT distRelativeDir envConfig0 executablePath <- liftIO getExecutablePath utf8EnvVars <- withProcessContext menv $ getUtf8EnvVars compilerVer mGhcRtsEnvVar <- liftIO $ lookupEnv "GHCRTS" envRef <- liftIO $ newIORef Map.empty let getProcessContext' es = do m <- readIORef envRef case Map.lookup es m of Just eo -> return eo Nothing -> do eo <- mkProcessContext $ Map.insert "PATH" (if esIncludeLocals es then localsPath else depsPath) $ (if esIncludeGhcPackagePath es then Map.insert (ghcPkgPathEnvVar wc) (mkGPP (esIncludeLocals es)) else id) $ (if esStackExe es then Map.insert "STACK_EXE" (T.pack executablePath) else id) $ (if esLocaleUtf8 es then Map.union utf8EnvVars else id) $ case (soptsSkipMsys sopts, platform) of (False, Platform Cabal.I386 Cabal.Windows) -> Map.insert "MSYSTEM" "MINGW32" (False, Platform Cabal.X86_64 Cabal.Windows) -> Map.insert "MSYSTEM" "MINGW64" _ -> id -- See https://github.com/commercialhaskell/stack/issues/3444 $ case (esKeepGhcRts es, mGhcRtsEnvVar) of (True, Just ghcRts) -> Map.insert "GHCRTS" (T.pack ghcRts) _ -> id -- For reasoning and duplication, see: https://github.com/fpco/stack/issues/70 $ Map.insert "HASKELL_PACKAGE_SANDBOX" (T.pack $ toFilePathNoTrailingSep deps) $ Map.insert "HASKELL_PACKAGE_SANDBOXES" (T.pack $ if esIncludeLocals es then intercalate [searchPathSeparator] [ toFilePathNoTrailingSep localdb , toFilePathNoTrailingSep deps , "" ] else intercalate [searchPathSeparator] [ toFilePathNoTrailingSep deps , "" ]) $ Map.insert "HASKELL_DIST_DIR" (T.pack $ toFilePathNoTrailingSep distDir) env () <- atomicModifyIORef envRef $ \m' -> (Map.insert es eo m', ()) return eo envOverride <- liftIO $ getProcessContext' minimalEnvSettings return EnvConfig { envConfigBuildConfig = bconfig { bcConfig = maybe id addIncludeLib mghcBin $ set processContextL envOverride (view configL bconfig) { configProcessContextSettings = getProcessContext' } } , envConfigCabalVersion = cabalVer , envConfigCompilerVersion = compilerVer , envConfigCompilerBuild = compilerBuild , envConfigPackagesRef = envConfigPackagesRef envConfig0 , envConfigLoadedSnapshot = ls } -- | Add the include and lib paths to the given Config addIncludeLib :: ExtraDirs -> Config -> Config addIncludeLib (ExtraDirs _bins includes libs) config = config { configExtraIncludeDirs = Set.union (configExtraIncludeDirs config) (Set.fromList (map toFilePathNoTrailingSep includes)) , configExtraLibDirs = Set.union (configExtraLibDirs config) (Set.fromList (map toFilePathNoTrailingSep libs)) } -- | Ensure compiler (ghc or ghcjs) is installed and provide the PATHs to add if necessary ensureCompiler :: (HasConfig env, HasGHCVariant env) => SetupOpts -> RIO env (Maybe ExtraDirs, CompilerBuild, Bool) ensureCompiler sopts = do let wc = whichCompiler (soptsWantedCompiler sopts) when (getGhcVersion (soptsWantedCompiler sopts) < $(mkVersion "7.8")) $ do logWarn "Stack will almost certainly fail with GHC below version 7.8" logWarn "Valiantly attempting to run anyway, but I know this is doomed" logWarn "For more information, see: https://github.com/commercialhaskell/stack/issues/648" logWarn "" msystem <- if soptsUseSystem sopts then do logDebug "Getting system compiler version" getSystemCompiler wc else return Nothing Platform expectedArch _ <- view platformL let canUseCompiler compilerVersion arch | soptsSkipGhcCheck sopts = True | otherwise = isWanted compilerVersion && arch == expectedArch isWanted = isWantedCompiler (soptsCompilerCheck sopts) (soptsWantedCompiler sopts) needLocal = not (any (uncurry canUseCompiler) msystem) getSetupInfo' <- runOnce (getSetupInfo (soptsSetupInfoYaml sopts)) let getMmsys2Tool = do platform <- view platformL localPrograms <- view $ configL.to configLocalPrograms installed <- listInstalled localPrograms case platform of Platform _ Cabal.Windows | not (soptsSkipMsys sopts) -> case getInstalledTool installed $(mkPackageName "msys2") (const True) of Just tool -> return (Just tool) Nothing | soptsInstallIfMissing sopts -> do si <- getSetupInfo' osKey <- getOSKey platform config <- view configL VersionedDownloadInfo version info <- case Map.lookup osKey $ siMsys2 si of Just x -> return x Nothing -> throwString $ "MSYS2 not found for " ++ T.unpack osKey let tool = Tool (PackageIdentifier $(mkPackageName "msys2") version) Just <$> downloadAndInstallTool (configLocalPrograms config) si info tool (installMsys2Windows osKey) | otherwise -> do logWarn "Continuing despite missing tool: msys2" return Nothing _ -> return Nothing -- If we need to install a GHC or MSYS, try to do so -- Return the additional directory paths of GHC & MSYS. (mtools, compilerBuild) <- if needLocal then do -- Install GHC ghcVariant <- view ghcVariantL config <- view configL let localPrograms = configLocalPrograms config installed <- listInstalled localPrograms possibleCompilers <- case wc of Ghc -> do ghcBuilds <- getGhcBuilds forM ghcBuilds $ \ghcBuild -> do ghcPkgName <- parsePackageNameFromString ("ghc" ++ ghcVariantSuffix ghcVariant ++ compilerBuildSuffix ghcBuild) return (getInstalledTool installed ghcPkgName (isWanted . GhcVersion), ghcBuild) Ghcjs -> return [(getInstalledGhcjs installed isWanted, CompilerBuildStandard)] let existingCompilers = concatMap (\(installedCompiler, compilerBuild) -> case (installedCompiler, soptsForceReinstall sopts) of (Just tool, False) -> [(tool, compilerBuild)] _ -> []) possibleCompilers logDebug $ "Found already installed GHC builds: " <> mconcat (intersperse ", " (map (fromString . compilerBuildName . snd) existingCompilers)) (compilerTool, compilerBuild) <- case existingCompilers of (tool, build_):_ -> return (tool, build_) [] | soptsInstallIfMissing sopts -> do si <- getSetupInfo' downloadAndInstallPossibleCompilers (map snd possibleCompilers) si (soptsWantedCompiler sopts) (soptsCompilerCheck sopts) (soptsGHCBindistURL sopts) | otherwise -> do recommendSystemGhc <- if soptsUseSystem sopts then return False else do msystemGhc <- getSystemCompiler wc return (any (uncurry canUseCompiler) msystemGhc) let suggestion = fromMaybe (mconcat ([ "To install the correct GHC into " , T.pack (toFilePath (configLocalPrograms config)) , ", try running \"stack setup\" or use the \"--install-ghc\" flag." ] ++ [ " To use your system GHC installation, run \"stack config set system-ghc --global true\", or use the \"--system-ghc\" flag." | recommendSystemGhc ])) (soptsResolveMissingGHC sopts) throwM $ CompilerVersionMismatch msystem (soptsWantedCompiler sopts, expectedArch) ghcVariant (case possibleCompilers of [] -> CompilerBuildStandard (_, compilerBuild):_ -> compilerBuild) (soptsCompilerCheck sopts) (soptsStackYaml sopts) suggestion -- Install msys2 on windows, if necessary mmsys2Tool <- getMmsys2Tool return (Just (Just compilerTool, mmsys2Tool), compilerBuild) -- Have the right ghc, may still need msys else do mmsys2Tool <- getMmsys2Tool return (Just (Nothing, mmsys2Tool), CompilerBuildStandard) mpaths <- case mtools of Nothing -> return Nothing Just (compilerTool, mmsys2Tool) -> do -- Add GHC's and MSYS's paths to the config. let idents = catMaybes [compilerTool, mmsys2Tool] paths <- mapM extraDirs idents return $ Just $ mconcat paths menv <- case mpaths of Nothing -> view processContextL Just ed -> do menv0 <- view processContextL m <- either throwM return $ augmentPathMap (toFilePath <$> edBins ed) (view envVarsL menv0) mkProcessContext (removeHaskellEnvVars m) forM_ (soptsUpgradeCabal sopts) $ \version -> do unless needLocal $ do logWarn "Trying to change a Cabal library on a GHC not installed by stack." logWarn "This may fail, caveat emptor!" withProcessContext menv $ upgradeCabal wc version case mtools of Just (Just (ToolGhcjs cv), _) -> withProcessContext menv $ ensureGhcjsBooted cv (soptsInstallIfMissing sopts) (soptsGHCJSBootOpts sopts) _ -> return () when (soptsSanityCheck sopts) $ withProcessContext menv $ sanityCheck wc return (mpaths, compilerBuild, needLocal) -- | Determine which GHC builds to use depending on which shared libraries are available -- on the system. getGhcBuilds :: HasConfig env => RIO env [CompilerBuild] getGhcBuilds = do config <- view configL case configGHCBuild config of Just ghcBuild -> return [ghcBuild] Nothing -> determineGhcBuild where determineGhcBuild = do -- TODO: a more reliable, flexible, and data driven approach would be to actually download small -- "test" executables (from setup-info) that link to the same gmp/tinfo versions -- that GHC does (i.e. built in same environment as the GHC bindist). The algorithm would go -- something like this: -- -- check for previous 'uname -a'/`ldconfig -p` plus compiler version/variant in cache -- if cached, then use that as suffix -- otherwise: -- download setup-info -- go through all with right prefix for os/version/variant -- first try "standard" (no extra suffix), then the rest -- download "compatibility check" exe if not already downloaded -- try running it -- if successful, then choose that -- cache compiler suffix with the uname -a and ldconfig -p output hash plus compiler version -- -- Of course, could also try to make a static GHC bindist instead of all this rigamarole. platform <- view platformL case platform of Platform _ Cabal.Linux -> do -- Some systems don't have ldconfig in the PATH, so make sure to look in /sbin and /usr/sbin as well let sbinEnv m = Map.insert "PATH" ("/sbin:/usr/sbin" <> maybe "" (":" <>) (Map.lookup "PATH" m)) m eldconfigOut <- withModifyEnvVars sbinEnv $ proc "ldconfig" ["-p"] $ tryAny . fmap fst . readProcess_ let firstWords = case eldconfigOut of Right ldconfigOut -> mapMaybe (listToMaybe . T.words) $ T.lines $ T.decodeUtf8With T.lenientDecode $ LBS.toStrict ldconfigOut Left _ -> [] checkLib lib | libT `elem` firstWords = do logDebug ("Found shared library " <> libD <> " in 'ldconfig -p' output") return True | otherwise = do #ifdef WINDOWS -- (mkAbsDir "/usr/lib") fails to compile on Windows, thus the CPP return False #else -- This is a workaround for the fact that libtinfo.so.6 doesn't appear in -- the 'ldconfig -p' output on Arch even when it exists. -- There doesn't seem to be an easy way to get the true list of directories -- to scan for shared libs, but this works for our particular case. e <- doesFileExist ($(mkAbsDir "/usr/lib") lib) if e then logDebug ("Found shared library " <> libD <> " in /usr/lib") else logDebug ("Did not find shared library " <> libD) return e #endif where libT = T.pack (toFilePath lib) libD = fromString (toFilePath lib) hastinfo5 <- checkLib $(mkRelFile "libtinfo.so.5") hastinfo6 <- checkLib $(mkRelFile "libtinfo.so.6") hasncurses6 <- checkLib $(mkRelFile "libncursesw.so.6") hasgmp5 <- checkLib $(mkRelFile "libgmp.so.10") hasgmp4 <- checkLib $(mkRelFile "libgmp.so.3") let libComponents = concat [ [["tinfo6"] | hastinfo6 && hasgmp5] , [[] | hastinfo5 && hasgmp5] , [["ncurses6"] | hasncurses6 && hasgmp5 ] , [["gmp4"] | hasgmp4 ] ] useBuilds $ map (\c -> case c of [] -> CompilerBuildStandard _ -> CompilerBuildSpecialized (intercalate "-" c)) libComponents #if !WINDOWS Platform _ Cabal.OpenBSD -> do releaseStr <- mungeRelease <$> sysRelease useBuilds [CompilerBuildSpecialized releaseStr] #endif _ -> useBuilds [CompilerBuildStandard] useBuilds builds = do logDebug $ "Potential GHC builds: " <> mconcat (intersperse ", " (map (fromString . compilerBuildName) builds)) return builds #if !WINDOWS -- | Encode an OpenBSD version (like "6.1") into a valid argument for -- CompilerBuildSpecialized, so "maj6-min1". Later version numbers are prefixed -- with "r". -- The result r must be such that "ghc-" ++ r is a valid package name, -- as recognized by parsePackageNameFromString. mungeRelease :: String -> String mungeRelease = intercalate "-" . prefixMaj . splitOn "." where prefixFst pfx k (rev : revs) = (pfx ++ rev) : k revs prefixFst _ _ [] = [] prefixMaj = prefixFst "maj" prefixMin prefixMin = prefixFst "min" (map ('r':)) sysRelease :: HasLogFunc env => RIO env String sysRelease = handleIO (\e -> do logWarn $ "Could not query OS version" <> displayShow e return "") . liftIO . alloca $ \ ptr -> do throwErrnoIfMinus1_ "uname" $ uname ptr peekCString $ release ptr #endif -- | Ensure Docker container-compatible 'stack' executable is downloaded ensureDockerStackExe :: HasConfig env => Platform -> RIO env (Path Abs File) ensureDockerStackExe containerPlatform = do config <- view configL containerPlatformDir <- runReaderT platformOnlyRelDir (containerPlatform,PlatformVariantNone) let programsPath = configLocalProgramsBase config containerPlatformDir tool = Tool (PackageIdentifier $(mkPackageName "stack") stackVersion) stackExeDir <- installDir programsPath tool let stackExePath = stackExeDir $(mkRelFile "stack") stackExeExists <- doesFileExist stackExePath unless stackExeExists $ do logInfo $ "Downloading Docker-compatible " <> fromString stackProgName <> " executable" sri <- downloadStackReleaseInfo Nothing Nothing (Just (versionString stackMinorVersion)) platforms <- runReaderT preferredPlatforms (containerPlatform, PlatformVariantNone) downloadStackExe platforms sri stackExeDir False (const $ return ()) return stackExePath -- | Install the newest version or a specific version of Cabal globally upgradeCabal :: (HasConfig env, HasGHCVariant env) => WhichCompiler -> UpgradeTo -> RIO env () upgradeCabal wc upgradeTo = do logWarn "Using deprecated --upgrade-cabal feature, this is not recommended" logWarn "Manipulating the global Cabal is only for debugging purposes" let name = $(mkPackageName "Cabal") rmap <- resolvePackages Nothing mempty (Set.singleton name) installed <- getCabalPkgVer wc case upgradeTo of Specific wantedVersion -> do if installed /= wantedVersion then doCabalInstall wc installed wantedVersion else logInfo $ "No install necessary. Cabal " <> RIO.display installed <> " is already installed" Latest -> case map rpIdent rmap of [] -> throwString "No Cabal library found in index, cannot upgrade" [PackageIdentifier name' latestVersion] | name == name' -> do if installed < latestVersion then doCabalInstall wc installed latestVersion else logInfo $ "No upgrade necessary: Cabal-" <> RIO.display latestVersion <> " is the same or newer than latest hackage version " <> RIO.display installed x -> error $ "Unexpected results for resolvePackages: " ++ show x -- Configure and run the necessary commands for a cabal install doCabalInstall :: (HasConfig env, HasGHCVariant env) => WhichCompiler -> Version -> Version -> RIO env () doCabalInstall wc installed wantedVersion = do when (wantedVersion >= $(mkVersion "2.2")) $ do logWarn "--upgrade-cabal will almost certainly fail for Cabal 2.2 or later" logWarn "See: https://github.com/commercialhaskell/stack/issues/4070" logWarn "Valiantly attempting to build it anyway, but I know this is doomed" withSystemTempDir "stack-cabal-upgrade" $ \tmpdir -> do logInfo $ "Installing Cabal-" <> RIO.display wantedVersion <> " to replace " <> RIO.display installed let name = $(mkPackageName "Cabal") ident = PackageIdentifier name wantedVersion m <- unpackPackageIdents tmpdir Nothing [PackageIdentifierRevision ident CFILatest] compilerPath <- findExecutable (compilerExeName wc) >>= either throwM parseAbsFile versionDir <- parseRelDir $ versionString wantedVersion let installRoot = toFilePath $ parent (parent compilerPath) $(mkRelDir "new-cabal") versionDir dir <- case Map.lookup ident m of Nothing -> error "upgradeCabal: Invariant violated, dir missing" Just dir -> return dir withWorkingDir (toFilePath dir) $ proc (compilerExeName wc) ["Setup.hs"] runProcess_ platform <- view platformL let setupExe = toFilePath $ dir case platform of Platform _ Cabal.Windows -> $(mkRelFile "Setup.exe") _ -> $(mkRelFile "Setup") dirArgument name' = concat [ "--" , name' , "dir=" , installRoot FP. name' ] args = "configure" : map dirArgument (words "lib bin data doc") withWorkingDir (toFilePath dir) $ do proc setupExe args runProcess_ proc setupExe ["build"] runProcess_ proc setupExe ["install"] runProcess_ logInfo "New Cabal library installed" -- | Get the version of the system compiler, if available getSystemCompiler :: (HasProcessContext env, HasLogFunc env) => WhichCompiler -> RIO env (Maybe (CompilerVersion 'CVActual, Arch)) getSystemCompiler wc = do let exeName = case wc of Ghc -> "ghc" Ghcjs -> "ghcjs" exists <- doesExecutableExist exeName if exists then do eres <- proc exeName ["--info"] $ tryAny . fmap fst . readProcess_ let minfo = do Right lbs <- Just eres pairs_ <- readMaybe $ BL8.unpack lbs :: Maybe [(String, String)] version <- lookup "Project version" pairs_ >>= parseVersionFromString arch <- lookup "Target platform" pairs_ >>= simpleParse . takeWhile (/= '-') return (version, arch) case (wc, minfo) of (Ghc, Just (version, arch)) -> return (Just (GhcVersion version, arch)) (Ghcjs, Just (_, arch)) -> do eversion <- tryAny $ getCompilerVersion Ghcjs case eversion of Left _ -> return Nothing Right version -> return (Just (version, arch)) (_, Nothing) -> return Nothing else return Nothing -- | Download the most recent SetupInfo getSetupInfo :: HasConfig env => String -> RIO env SetupInfo getSetupInfo stackSetupYaml = do config <- view configL setupInfos <- mapM loadSetupInfo (SetupInfoFileOrURL stackSetupYaml : configSetupInfoLocations config) return (mconcat setupInfos) where loadSetupInfo (SetupInfoInline si) = return si loadSetupInfo (SetupInfoFileOrURL urlOrFile) = do bs <- case parseUrlThrow urlOrFile of Just req -> liftM (LBS.toStrict . getResponseBody) $ httpLBS req Nothing -> liftIO $ S.readFile urlOrFile WithJSONWarnings si warnings <- either throwM return (Yaml.decodeEither' bs) when (urlOrFile /= defaultSetupInfoYaml) $ logJSONWarnings urlOrFile warnings return si getInstalledTool :: [Tool] -- ^ already installed -> PackageName -- ^ package to find -> (Version -> Bool) -- ^ which versions are acceptable -> Maybe Tool getInstalledTool installed name goodVersion = if null available then Nothing else Just $ Tool $ maximumBy (comparing packageIdentifierVersion) available where available = mapMaybe goodPackage installed goodPackage (Tool pi') = if packageIdentifierName pi' == name && goodVersion (packageIdentifierVersion pi') then Just pi' else Nothing goodPackage _ = Nothing getInstalledGhcjs :: [Tool] -> (CompilerVersion 'CVActual -> Bool) -> Maybe Tool getInstalledGhcjs installed goodVersion = if null available then Nothing else Just $ ToolGhcjs $ maximum available where available = mapMaybe goodPackage installed goodPackage (ToolGhcjs cv) = if goodVersion cv then Just cv else Nothing goodPackage _ = Nothing downloadAndInstallTool :: HasRunner env => Path Abs Dir -> SetupInfo -> DownloadInfo -> Tool -> (SetupInfo -> Path Abs File -> ArchiveType -> Path Abs Dir -> Path Abs Dir -> RIO env ()) -> RIO env Tool downloadAndInstallTool programsDir si downloadInfo tool installer = do ensureDir programsDir (file, at) <- downloadFromInfo programsDir downloadInfo tool dir <- installDir programsDir tool tempDir <- tempInstallDir programsDir tool liftIO $ ignoringAbsence (removeDirRecur tempDir) ensureDir tempDir unmarkInstalled programsDir tool installer si file at tempDir dir markInstalled programsDir tool liftIO $ ignoringAbsence (removeDirRecur tempDir) return tool downloadAndInstallCompiler :: (HasConfig env, HasGHCVariant env) => CompilerBuild -> SetupInfo -> CompilerVersion 'CVWanted -> VersionCheck -> Maybe String -> RIO env Tool downloadAndInstallCompiler ghcBuild si wanted@GhcVersion{} versionCheck mbindistURL = do ghcVariant <- view ghcVariantL (selectedVersion, downloadInfo) <- case mbindistURL of Just bindistURL -> do case ghcVariant of GHCCustom _ -> return () _ -> throwM RequireCustomGHCVariant case wanted of GhcVersion version -> return (version, GHCDownloadInfo mempty mempty DownloadInfo { downloadInfoUrl = T.pack bindistURL , downloadInfoContentLength = Nothing , downloadInfoSha1 = Nothing , downloadInfoSha256 = Nothing }) _ -> throwM WantedMustBeGHC _ -> do ghcKey <- getGhcKey ghcBuild case Map.lookup ghcKey $ siGHCs si of Nothing -> throwM $ UnknownOSKey ghcKey Just pairs_ -> getWantedCompilerInfo ghcKey versionCheck wanted GhcVersion pairs_ config <- view configL let installer = case configPlatform config of Platform _ Cabal.Windows -> installGHCWindows selectedVersion _ -> installGHCPosix selectedVersion downloadInfo logInfo $ "Preparing to install GHC" <> (case ghcVariant of GHCStandard -> "" v -> " (" <> fromString (ghcVariantName v) <> ")") <> (case ghcBuild of CompilerBuildStandard -> "" b -> " (" <> fromString (compilerBuildName b) <> ")") <> " to an isolated location." logInfo "This will not interfere with any system-level installation." ghcPkgName <- parsePackageNameFromString ("ghc" ++ ghcVariantSuffix ghcVariant ++ compilerBuildSuffix ghcBuild) let tool = Tool $ PackageIdentifier ghcPkgName selectedVersion downloadAndInstallTool (configLocalPrograms config) si (gdiDownloadInfo downloadInfo) tool installer downloadAndInstallCompiler compilerBuild si wanted versionCheck _mbindistUrl = do config <- view configL ghcVariant <- view ghcVariantL case (ghcVariant, compilerBuild) of (GHCStandard, CompilerBuildStandard) -> return () _ -> throwM GHCJSRequiresStandardVariant (selectedVersion, downloadInfo) <- case Map.lookup "source" $ siGHCJSs si of Nothing -> throwM $ UnknownOSKey "source" Just pairs_ -> getWantedCompilerInfo "source" versionCheck wanted id pairs_ logInfo "Preparing to install GHCJS to an isolated location." logInfo "This will not interfere with any system-level installation." let tool = ToolGhcjs selectedVersion downloadAndInstallTool (configLocalPrograms config) si downloadInfo tool installGHCJS getWantedCompilerInfo :: (Ord k, MonadThrow m) => Text -> VersionCheck -> CompilerVersion 'CVWanted -> (k -> CompilerVersion 'CVActual) -> Map k a -> m (k, a) getWantedCompilerInfo key versionCheck wanted toCV pairs_ = case mpair of Just pair -> return pair Nothing -> throwM $ UnknownCompilerVersion (Set.singleton key) wanted (Set.fromList $ map toCV (Map.keys pairs_)) where mpair = listToMaybe $ sortBy (flip (comparing fst)) $ filter (isWantedCompiler versionCheck wanted . toCV . fst) (Map.toList pairs_) -- | Download and install the first available compiler build. downloadAndInstallPossibleCompilers :: (HasGHCVariant env, HasConfig env) => [CompilerBuild] -> SetupInfo -> CompilerVersion 'CVWanted -> VersionCheck -> Maybe String -> RIO env (Tool, CompilerBuild) downloadAndInstallPossibleCompilers possibleCompilers si wanted versionCheck mbindistURL = go possibleCompilers Nothing where -- This will stop as soon as one of the builds doesn't throw an @UnknownOSKey@ or -- @UnknownCompilerVersion@ exception (so it will only try subsequent builds if one is non-existent, -- not if the download or install fails for some other reason). -- The @Unknown*@ exceptions thrown by each attempt are combined into a single exception -- (if only @UnknownOSKey@ is thrown, then the first of those is rethrown, but if any -- @UnknownCompilerVersion@s are thrown then the attempted OS keys and available versions -- are unioned). go [] Nothing = throwM UnsupportedSetupConfiguration go [] (Just e) = throwM e go (b:bs) e = do logDebug $ "Trying to setup GHC build: " <> fromString (compilerBuildName b) er <- try $ downloadAndInstallCompiler b si wanted versionCheck mbindistURL case er of Left e'@(UnknownCompilerVersion ks' w' vs') -> case e of Nothing -> go bs (Just e') Just (UnknownOSKey k) -> go bs $ Just $ UnknownCompilerVersion (Set.insert k ks') w' vs' Just (UnknownCompilerVersion ks _ vs) -> go bs $ Just $ UnknownCompilerVersion (Set.union ks' ks) w' (Set.union vs' vs) Just x -> throwM x Left e'@(UnknownOSKey k') -> case e of Nothing -> go bs (Just e') Just (UnknownOSKey _) -> go bs e Just (UnknownCompilerVersion ks w vs) -> go bs $ Just $ UnknownCompilerVersion (Set.insert k' ks) w vs Just x -> throwM x Left e' -> throwM e' Right r -> return (r, b) getGhcKey :: (MonadReader env m, HasPlatform env, HasGHCVariant env, MonadThrow m) => CompilerBuild -> m Text getGhcKey ghcBuild = do ghcVariant <- view ghcVariantL platform <- view platformL osKey <- getOSKey platform return $ osKey <> T.pack (ghcVariantSuffix ghcVariant) <> T.pack (compilerBuildSuffix ghcBuild) getOSKey :: (MonadThrow m) => Platform -> m Text getOSKey platform = case platform of Platform I386 Cabal.Linux -> return "linux32" Platform X86_64 Cabal.Linux -> return "linux64" Platform I386 Cabal.OSX -> return "macosx" Platform X86_64 Cabal.OSX -> return "macosx" Platform I386 Cabal.FreeBSD -> return "freebsd32" Platform X86_64 Cabal.FreeBSD -> return "freebsd64" Platform I386 Cabal.OpenBSD -> return "openbsd32" Platform X86_64 Cabal.OpenBSD -> return "openbsd64" Platform I386 Cabal.Windows -> return "windows32" Platform X86_64 Cabal.Windows -> return "windows64" Platform Arm Cabal.Linux -> return "linux-armv7" Platform (OtherArch "aarch64") Cabal.Linux -> return "linux-aarch64" Platform arch os -> throwM $ UnsupportedSetupCombo os arch downloadFromInfo :: HasRunner env => Path Abs Dir -> DownloadInfo -> Tool -> RIO env (Path Abs File, ArchiveType) downloadFromInfo programsDir downloadInfo tool = do at <- case extension of ".tar.xz" -> return TarXz ".tar.bz2" -> return TarBz2 ".tar.gz" -> return TarGz ".7z.exe" -> return SevenZ _ -> throwString $ "Error: Unknown extension for url: " ++ url relativeFile <- parseRelFile $ toolString tool ++ extension path <- case url of (parseUrlThrow -> Just _) -> do let path = programsDir relativeFile ensureDir programsDir chattyDownload (T.pack (toolString tool)) downloadInfo path return path (parseAbsFile -> Just path) -> do let DownloadInfo{downloadInfoContentLength=contentLength, downloadInfoSha1=sha1, downloadInfoSha256=sha256} = downloadInfo when (isJust contentLength) $ logWarn ("`content-length` in not checked \n" <> "and should not be specified when `url` is a file path") when (isJust sha1) $ logWarn ("`sha1` is not checked and \n" <> "should not be specified when `url` is a file path") when (isJust sha256) $ logWarn ("`sha256` is not checked and \n" <> "should not be specified when `url` is a file path") return path _ -> throwString $ "Error: `url` must be either an HTTP URL or absolute file path: " ++ url return (path, at) where url = T.unpack $ downloadInfoUrl downloadInfo extension = loop url where loop fp | ext `elem` [".tar", ".bz2", ".xz", ".exe", ".7z", ".gz"] = loop fp' ++ ext | otherwise = "" where (fp', ext) = FP.splitExtension fp data ArchiveType = TarBz2 | TarXz | TarGz | SevenZ installGHCPosix :: HasConfig env => Version -> GHCDownloadInfo -> SetupInfo -> Path Abs File -> ArchiveType -> Path Abs Dir -> Path Abs Dir -> RIO env () installGHCPosix version downloadInfo _ archiveFile archiveType tempDir destDir = do platform <- view platformL menv0 <- view processContextL menv <- mkProcessContext (removeHaskellEnvVars (view envVarsL menv0)) logDebug $ "menv = " <> displayShow (view envVarsL menv) (zipTool', compOpt) <- case archiveType of TarXz -> return ("xz", 'J') TarBz2 -> return ("bzip2", 'j') TarGz -> return ("gzip", 'z') SevenZ -> throwString "Don't know how to deal with .7z files on non-Windows" -- Slight hack: OpenBSD's tar doesn't support xz. -- https://github.com/commercialhaskell/stack/issues/2283#issuecomment-237980986 let tarDep = case (platform, archiveType) of (Platform _ Cabal.OpenBSD, TarXz) -> checkDependency "gtar" _ -> checkDependency "tar" (zipTool, makeTool, tarTool) <- checkDependencies $ (,,) <$> checkDependency zipTool' <*> (checkDependency "gmake" <|> checkDependency "make") <*> tarDep logDebug $ "ziptool: " <> fromString zipTool logDebug $ "make: " <> fromString makeTool logDebug $ "tar: " <> fromString tarTool dir <- liftM (tempDir ) $ parseRelDir $ "ghc-" ++ versionString version let runStep step wd env cmd args = do menv' <- modifyEnvVars menv (Map.union env) result <- do let logLines = CB.lines .| CL.mapM_ (logDebug . displayBytesUtf8) withWorkingDir (toFilePath wd) $ withProcessContext menv' $ try $ sinkProcessStderrStdout cmd args logLines logLines case result of Right ((), ()) -> return () Left ex -> do logError (displayShow (ex :: ProcessException)) prettyError $ hang 2 ("Error encountered while" <+> step <+> "GHC with" <> line <> styleShell (fromString (unwords (cmd : args))) <> line <> -- TODO: Figure out how to insert \ in the appropriate spots -- hang 2 (shellColor (fillSep (fromString cmd : map fromString args))) <> line <> "run in " <> display wd) <> line <> line <> "The following directories may now contain files, but won't be used by stack:" <> line <> " -" <+> display tempDir <> line <> " -" <+> display destDir <> line liftIO System.Exit.exitFailure logSticky $ "Unpacking GHC into " <> fromString (toFilePath tempDir) <> " ..." logDebug $ "Unpacking " <> fromString (toFilePath archiveFile) runStep "unpacking" tempDir mempty tarTool [compOpt : "xf", toFilePath archiveFile] logSticky "Configuring GHC ..." runStep "configuring" dir (gdiConfigureEnv downloadInfo) (toFilePath $ dir $(mkRelFile "configure")) (("--prefix=" ++ toFilePath destDir) : map T.unpack (gdiConfigureOpts downloadInfo)) logSticky "Installing GHC ..." runStep "installing" dir mempty makeTool ["install"] logStickyDone $ "Installed GHC." logDebug $ "GHC installed to " <> fromString (toFilePath destDir) installGHCJS :: HasConfig env => SetupInfo -> Path Abs File -> ArchiveType -> Path Abs Dir -> Path Abs Dir -> RIO env () installGHCJS si archiveFile archiveType _tempDir destDir = do platform <- view platformL menv0 <- view processContextL -- This ensures that locking is disabled for the invocations of -- stack below. let removeLockVar = Map.delete "STACK_LOCK" menv <- mkProcessContext (removeLockVar (removeHaskellEnvVars (view envVarsL menv0))) logDebug $ "menv = " <> displayShow (view envVarsL menv) -- NOTE: this is a bit of a hack - instead of using the temp -- directory, leave the unpacked source tarball in the destination -- directory. This way, the absolute paths in the wrapper scripts -- will point to executables that exist in -- src/.stack-work/install/... - see -- https://github.com/commercialhaskell/stack/issues/1016 -- -- This is also used by 'ensureGhcjsBooted', because it can use the -- environment of the stack.yaml which came with ghcjs, in order to -- install cabal-install. This lets us also fix the version of -- cabal-install used. let unpackDir = destDir $(mkRelDir "src") runUnpack <- case platform of Platform _ Cabal.Windows -> return $ withUnpackedTarball7z "GHCJS" si archiveFile archiveType Nothing unpackDir _ -> do zipTool' <- case archiveType of TarXz -> return "xz" TarBz2 -> return "bzip2" TarGz -> return "gzip" SevenZ -> throwString "Don't know how to deal with .7z files on non-Windows" (zipTool, tarTool) <- checkDependencies $ (,) <$> checkDependency zipTool' <*> checkDependency "tar" logDebug $ "ziptool: " <> fromString zipTool logDebug $ "tar: " <> fromString tarTool return $ do liftIO $ ignoringAbsence (removeDirRecur destDir) liftIO $ ignoringAbsence (removeDirRecur unpackDir) withProcessContext menv $ withWorkingDir (toFilePath destDir) $ readProcessNull tarTool ["xf", toFilePath archiveFile] innerDir <- expectSingleUnpackedDir archiveFile destDir renameDir innerDir unpackDir logSticky $ "Unpacking GHCJS into " <> fromString (toFilePath unpackDir) <> " ..." logDebug $ "Unpacking " <> fromString (toFilePath archiveFile) runUnpack logSticky "Setting up GHCJS build environment" let stackYaml = unpackDir $(mkRelFile "stack.yaml") destBinDir = destDir $(mkRelDir "bin") ensureDir destBinDir envConfig' <- loadGhcjsEnvConfig stackYaml destBinDir -- On windows we need to copy options files out of the install dir. Argh! -- This is done before the build, so that if it fails, things fail -- earlier. mwindowsInstallDir <- case platform of Platform _ Cabal.Windows -> liftM Just $ runRIO envConfig' installationRootLocal _ -> return Nothing logSticky "Installing GHCJS (this will take a long time) ..." buildInGhcjsEnv envConfig' defaultBuildOptsCLI -- Copy over *.options files needed on windows. forM_ mwindowsInstallDir $ \dir -> do (_, files) <- listDir (dir $(mkRelDir "bin")) forM_ (filter ((".options" `isSuffixOf`). toFilePath) files) $ \optionsFile -> do let dest = destDir $(mkRelDir "bin") filename optionsFile liftIO $ ignoringAbsence (removeFile dest) copyFile optionsFile dest logStickyDone "Installed GHCJS." ensureGhcjsBooted :: HasConfig env => CompilerVersion 'CVActual -> Bool -> [String] -> RIO env () ensureGhcjsBooted cv shouldBoot bootOpts = do eres <- try $ sinkProcessStdout "ghcjs" [] (return ()) case eres of Right () -> return () Left ece | "no input files" `S.isInfixOf` LBS.toStrict (eceStderr ece) -> return () Left ece | "ghcjs_boot.completed" `S.isInfixOf` LBS.toStrict (eceStderr ece) -> if not shouldBoot then throwM GHCJSNotBooted else do config <- view configL destDir <- installDir (configLocalPrograms config) (ToolGhcjs cv) let stackYaml = destDir $(mkRelFile "src/stack.yaml") -- TODO: Remove 'actualStackYaml' and just use -- 'stackYaml' for a version after 0.1.6. It's for -- compatibility with the directories setup used for -- most of the life of the development branch between -- 0.1.5 and 0.1.6. See -- https://github.com/commercialhaskell/stack/issues/749#issuecomment-147382783 -- This only affects the case where GHCJS has been -- installed with an older version and not yet booted. stackYamlExists <- doesFileExist stackYaml ghcjsVersion <- case cv of GhcjsVersion version _ -> return version _ -> error "ensureGhcjsBooted invoked on non GhcjsVersion" actualStackYaml <- if stackYamlExists then return stackYaml else liftM ((destDir $(mkRelDir "src")) ) $ parseRelFile $ "ghcjs-" ++ versionString ghcjsVersion ++ "/stack.yaml" actualStackYamlExists <- doesFileExist actualStackYaml unless actualStackYamlExists $ throwString "Error: Couldn't find GHCJS stack.yaml in old or new location." bootGhcjs ghcjsVersion actualStackYaml destDir bootOpts Left ece -> throwIO ece bootGhcjs :: (HasRunner env, HasProcessContext env) => Version -> Path Abs File -> Path Abs Dir -> [String] -> RIO env () bootGhcjs ghcjsVersion stackYaml destDir bootOpts = do envConfig <- loadGhcjsEnvConfig stackYaml (destDir $(mkRelDir "bin")) menv <- liftIO $ configProcessContextSettings (view configL envConfig) defaultEnvSettings -- Install cabal-install if missing, or if the installed one is old. mcabal <- withProcessContext menv getCabalInstallVersion shouldInstallCabal <- case mcabal of Nothing -> do logInfo "No cabal-install binary found for use with GHCJS." return True Just v | v < $(mkVersion "1.22.4") -> do logInfo $ "The cabal-install found on PATH is too old to be used for booting GHCJS (version " <> RIO.display v <> ")." return True | v >= $(mkVersion "1.23") -> do logWarn $ "The cabal-install found on PATH is a version stack doesn't know about, version " <> RIO.display v <> ". This may or may not work.\n" <> "See this issue: https://github.com/ghcjs/ghcjs/issues/470" return False | ghcjsVersion >= $(mkVersion "0.2.0.20160413") && v >= $(mkVersion "1.22.8") -> do logWarn $ "The cabal-install found on PATH, version " <> RIO.display v <> ", is >= 1.22.8.\n" <> "That version has a bug preventing ghcjs < 0.2.0.20160413 from booting.\n" <> "See this issue: https://github.com/ghcjs/ghcjs/issues/470" return True | otherwise -> return False let envSettings = EnvSettings { esIncludeLocals = True , esIncludeGhcPackagePath = False , esStackExe = True , esLocaleUtf8 = True , esKeepGhcRts = False } menv' <- liftIO $ configProcessContextSettings (view configL envConfig) envSettings shouldInstallAlex <- runRIO menv $ not <$> doesExecutableExist "alex" shouldInstallHappy <- runRIO menv $ not <$> doesExecutableExist "happy" let bootDepsToInstall = [ "cabal-install" | shouldInstallCabal ] ++ [ "alex" | shouldInstallAlex ] ++ [ "happy" | shouldInstallHappy ] when (not (null bootDepsToInstall)) $ do logInfo $ "Building tools from source, needed for ghcjs-boot: " <> displayShow bootDepsToInstall buildInGhcjsEnv envConfig $ defaultBuildOptsCLI { boptsCLITargets = bootDepsToInstall } let failedToFindErr = do logError "This shouldn't happen, because it gets built to the snapshot bin directory, which should be treated as being on the PATH." liftIO System.Exit.exitFailure when shouldInstallCabal $ do mcabal' <- withProcessContext menv' getCabalInstallVersion case mcabal' of Nothing -> do logError "Failed to get cabal-install version after installing it." failedToFindErr Just v | v >= $(mkVersion "1.22.8") && v < $(mkVersion "1.23") -> logWarn $ "Installed version of cabal-install is in a version range which may not work.\n" <> "See this issue: https://github.com/ghcjs/ghcjs/issues/470\n" <> "This version is specified by the stack.yaml file included in the ghcjs tarball.\n" _ -> return () when shouldInstallAlex $ do alexInstalled <- runRIO menv $ doesExecutableExist "alex" when (not alexInstalled) $ do logError "Failed to find 'alex' executable after installing it." failedToFindErr when shouldInstallHappy $ do happyInstalled <- runRIO menv $ doesExecutableExist "happy" when (not happyInstalled) $ do logError "Failed to find 'happy' executable after installing it." failedToFindErr logSticky "Booting GHCJS (this will take a long time) ..." withProcessContext menv' $ proc "ghcjs-boot" bootOpts logProcessStderrStdout logStickyDone "GHCJS booted." loadGhcjsEnvConfig :: HasRunner env => Path Abs File -> Path b t -> RIO env EnvConfig loadGhcjsEnvConfig stackYaml binPath = do lc <- loadConfig (mempty { configMonoidInstallGHC = First (Just True) , configMonoidLocalBinPath = First (Just (toFilePath binPath)) }) Nothing (SYLOverride stackYaml) bconfig <- liftIO $ lcLoadBuildConfig lc Nothing runRIO bconfig $ setupEnv Nothing buildInGhcjsEnv :: (HasEnvConfig env, MonadIO m) => env -> BuildOptsCLI -> m () buildInGhcjsEnv envConfig boptsCli = do runRIO (set (buildOptsL.buildOptsInstallExesL) True $ set (buildOptsL.buildOptsHaddockL) False envConfig) $ build (\_ -> return ()) Nothing boptsCli getCabalInstallVersion :: (HasProcessContext env, HasLogFunc env) => RIO env (Maybe Version) getCabalInstallVersion = do ebs <- tryAny $ proc "cabal" ["--numeric-version"] readProcess_ case ebs of Left _ -> return Nothing Right (bs, _) -> Just <$> parseVersion (T.dropWhileEnd isSpace (T.decodeUtf8 (LBS.toStrict bs))) -- | Check if given processes appear to be present, throwing an exception if -- missing. checkDependencies :: CheckDependency env a -> RIO env a checkDependencies (CheckDependency f) = f >>= either (throwIO . MissingDependencies) return checkDependency :: HasProcessContext env => String -> CheckDependency env String checkDependency tool = CheckDependency $ do exists <- doesExecutableExist tool return $ if exists then Right tool else Left [tool] newtype CheckDependency env a = CheckDependency (RIO env (Either [String] a)) deriving Functor instance Applicative (CheckDependency env) where pure x = CheckDependency $ return (Right x) CheckDependency f <*> CheckDependency x = CheckDependency $ do f' <- f x' <- x return $ case (f', x') of (Left e1, Left e2) -> Left $ e1 ++ e2 (Left e, Right _) -> Left e (Right _, Left e) -> Left e (Right f'', Right x'') -> Right $ f'' x'' instance Alternative (CheckDependency env) where empty = CheckDependency $ return $ Left [] CheckDependency x <|> CheckDependency y = CheckDependency $ do res1 <- x case res1 of Left _ -> y Right x' -> return $ Right x' installGHCWindows :: HasConfig env => Version -> SetupInfo -> Path Abs File -> ArchiveType -> Path Abs Dir -> Path Abs Dir -> RIO env () installGHCWindows version si archiveFile archiveType _tempDir destDir = do tarComponent <- parseRelDir $ "ghc-" ++ versionString version withUnpackedTarball7z "GHC" si archiveFile archiveType (Just tarComponent) destDir logInfo $ "GHC installed to " <> fromString (toFilePath destDir) installMsys2Windows :: HasConfig env => Text -- ^ OS Key -> SetupInfo -> Path Abs File -> ArchiveType -> Path Abs Dir -> Path Abs Dir -> RIO env () installMsys2Windows osKey si archiveFile archiveType _tempDir destDir = do exists <- liftIO $ D.doesDirectoryExist $ toFilePath destDir when exists $ liftIO (D.removeDirectoryRecursive $ toFilePath destDir) `catchIO` \e -> do logError $ "Could not delete existing msys directory: " <> fromString (toFilePath destDir) throwM e msys <- parseRelDir $ "msys" ++ T.unpack (fromMaybe "32" $ T.stripPrefix "windows" osKey) withUnpackedTarball7z "MSYS2" si archiveFile archiveType (Just msys) destDir -- I couldn't find this officially documented anywhere, but you need to run -- the MSYS shell once in order to initialize some pacman stuff. Once that -- run happens, you can just run commands as usual. menv0 <- view processContextL newEnv0 <- modifyEnvVars menv0 $ Map.insert "MSYSTEM" "MSYS" newEnv <- either throwM return $ augmentPathMap [toFilePath $ destDir $(mkRelDir "usr") $(mkRelDir "bin")] (view envVarsL newEnv0) menv <- mkProcessContext newEnv withWorkingDir (toFilePath destDir) $ withProcessContext menv $ proc "sh" ["--login", "-c", "true"] runProcess_ -- No longer installing git, it's unreliable -- (https://github.com/commercialhaskell/stack/issues/1046) and the -- MSYS2-installed version has bad CRLF defaults. -- -- Install git. We could install other useful things in the future too. -- runCmd (Cmd (Just destDir) "pacman" menv ["-Sy", "--noconfirm", "git"]) Nothing -- | Unpack a compressed tarball using 7zip. Expects a single directory in -- the unpacked results, which is renamed to the destination directory. withUnpackedTarball7z :: HasConfig env => String -- ^ Name of tool, used in error messages -> SetupInfo -> Path Abs File -- ^ Path to archive file -> ArchiveType -> Maybe (Path Rel Dir) -- ^ Name of directory expected in archive. If Nothing, expects a single folder. -> Path Abs Dir -- ^ Destination directory. -> RIO env () withUnpackedTarball7z name si archiveFile archiveType msrcDir destDir = do suffix <- case archiveType of TarXz -> return ".xz" TarBz2 -> return ".bz2" TarGz -> return ".gz" _ -> throwString $ name ++ " must be a tarball file" tarFile <- case T.stripSuffix suffix $ T.pack $ toFilePath (filename archiveFile) of Nothing -> throwString $ "Invalid " ++ name ++ " filename: " ++ show archiveFile Just x -> parseRelFile $ T.unpack x run7z <- setup7z si let tmpName = toFilePathNoTrailingSep (dirname destDir) ++ "-tmp" ensureDir (parent destDir) withRunInIO $ \run -> withTempDir (parent destDir) tmpName $ \tmpDir -> run $ do liftIO $ ignoringAbsence (removeDirRecur destDir) run7z tmpDir archiveFile run7z tmpDir (tmpDir tarFile) absSrcDir <- case msrcDir of Just srcDir -> return $ tmpDir srcDir Nothing -> expectSingleUnpackedDir archiveFile tmpDir renameDir absSrcDir destDir expectSingleUnpackedDir :: (MonadIO m, MonadThrow m) => Path Abs File -> Path Abs Dir -> m (Path Abs Dir) expectSingleUnpackedDir archiveFile destDir = do contents <- listDir destDir case contents of ([dir], _ ) -> return dir _ -> throwString $ "Expected a single directory within unpacked " ++ toFilePath archiveFile -- | Download 7z as necessary, and get a function for unpacking things. -- -- Returned function takes an unpack directory and archive. setup7z :: (HasConfig env, MonadIO m) => SetupInfo -> RIO env (Path Abs Dir -> Path Abs File -> m ()) setup7z si = do dir <- view $ configL.to configLocalPrograms ensureDir dir let exe = dir $(mkRelFile "7z.exe") dll = dir $(mkRelFile "7z.dll") case (siSevenzDll si, siSevenzExe si) of (Just sevenzDll, Just sevenzExe) -> do chattyDownload "7z.dll" sevenzDll dll chattyDownload "7z.exe" sevenzExe exe withRunInIO $ \run -> return $ \outdir archive -> liftIO $ run $ do let cmd = toFilePath exe args = [ "x" , "-o" ++ toFilePath outdir , "-y" , toFilePath archive ] ec <- proc cmd args runProcess when (ec /= ExitSuccess) $ liftIO $ throwM (ProblemWhileDecompressing archive) _ -> throwM SetupInfoMissingSevenz chattyDownload :: HasRunner env => Text -- ^ label -> DownloadInfo -- ^ URL, content-length, sha1, and sha256 -> Path Abs File -- ^ destination -> RIO env () chattyDownload label downloadInfo path = do let url = downloadInfoUrl downloadInfo req <- parseUrlThrow $ T.unpack url logSticky $ "Preparing to download " <> RIO.display label <> " ..." logDebug $ "Downloading from " <> RIO.display url <> " to " <> fromString (toFilePath path) <> " ..." hashChecks <- fmap catMaybes $ forM [ ("sha1", HashCheck SHA1, downloadInfoSha1) , ("sha256", HashCheck SHA256, downloadInfoSha256) ] $ \(name, constr, getter) -> case getter downloadInfo of Just bs -> do logDebug $ "Will check against " <> name <> " hash: " <> displayBytesUtf8 bs return $ Just $ constr $ CheckHexDigestByteString bs Nothing -> return Nothing when (null hashChecks) $ logWarn $ "No sha1 or sha256 found in metadata," <> " download hash won't be checked." let dReq = DownloadRequest { drRequest = req , drHashChecks = hashChecks , drLengthCheck = mtotalSize , drRetryPolicy = drRetryPolicyDefault } x <- verifiedDownload dReq path chattyDownloadProgress if x then logStickyDone ("Downloaded " <> RIO.display label <> ".") else logStickyDone "Already downloaded." where mtotalSize = downloadInfoContentLength downloadInfo chattyDownloadProgress _ = do _ <- logSticky $ RIO.display label <> ": download has begun" CL.map (Sum . S.length) .| chunksOverTime 1 .| go where go = evalStateC 0 $ awaitForever $ \(Sum size) -> do modify (+ size) totalSoFar <- get logSticky $ fromString $ case mtotalSize of Nothing -> chattyProgressNoTotal totalSoFar Just 0 -> chattyProgressNoTotal totalSoFar Just totalSize -> chattyProgressWithTotal totalSoFar totalSize -- Example: ghc: 42.13 KiB downloaded... chattyProgressNoTotal totalSoFar = printf ("%s: " <> bytesfmt "%7.2f" totalSoFar <> " downloaded...") (T.unpack label) -- Example: ghc: 50.00 MiB / 100.00 MiB (50.00%) downloaded... chattyProgressWithTotal totalSoFar total = printf ("%s: " <> bytesfmt "%7.2f" totalSoFar <> " / " <> bytesfmt "%.2f" total <> " (%6.2f%%) downloaded...") (T.unpack label) percentage where percentage :: Double percentage = fromIntegral totalSoFar / fromIntegral total * 100 -- | Given a printf format string for the decimal part and a number of -- bytes, formats the bytes using an appropiate unit and returns the -- formatted string. -- -- >>> bytesfmt "%.2" 512368 -- "500.359375 KiB" bytesfmt :: Integral a => String -> a -> String bytesfmt formatter bs = printf (formatter <> " %s") (fromIntegral (signum bs) * dec :: Double) (bytesSuffixes !! i) where (dec,i) = getSuffix (abs bs) getSuffix n = until p (\(x,y) -> (x / 1024, y+1)) (fromIntegral n,0) where p (n',numDivs) = n' < 1024 || numDivs == (length bytesSuffixes - 1) bytesSuffixes :: [String] bytesSuffixes = ["B","KiB","MiB","GiB","TiB","PiB","EiB","ZiB","YiB"] -- Await eagerly (collect with monoidal append), -- but space out yields by at least the given amount of time. -- The final yield may come sooner, and may be a superfluous mempty. -- Note that Integer and Float literals can be turned into NominalDiffTime -- (these literals are interpreted as "seconds") chunksOverTime :: (Monoid a, Semigroup a, MonadIO m) => NominalDiffTime -> ConduitM a a m () chunksOverTime diff = do currentTime <- liftIO getCurrentTime evalStateC (currentTime, mempty) go where -- State is a tuple of: -- * the last time a yield happened (or the beginning of the sink) -- * the accumulated awaits since the last yield go = await >>= \case Nothing -> do (_, acc) <- get yield acc Just a -> do (lastTime, acc) <- get let acc' = acc <> a currentTime <- liftIO getCurrentTime if diff < diffUTCTime currentTime lastTime then put (currentTime, mempty) >> yield acc' else put (lastTime, acc') go -- | Perform a basic sanity check of GHC sanityCheck :: (HasProcessContext env, HasLogFunc env) => WhichCompiler -> RIO env () sanityCheck wc = withSystemTempDir "stack-sanity-check" $ \dir -> do let fp = toFilePath $ dir $(mkRelFile "Main.hs") liftIO $ S.writeFile fp $ T.encodeUtf8 $ T.pack $ unlines [ "import Distribution.Simple" -- ensure Cabal library is present , "main = putStrLn \"Hello World\"" ] let exeName = compilerExeName wc ghc <- findExecutable exeName >>= either throwM parseAbsFile logDebug $ "Performing a sanity check on: " <> fromString (toFilePath ghc) eres <- withWorkingDir (toFilePath dir) $ proc exeName [ fp , "-no-user-package-db" ] $ try . readProcess_ case eres of Left e -> throwIO $ GHCSanityCheckCompileFailed e ghc Right _ -> return () -- TODO check that the output of running the command is correct -- Remove potentially confusing environment variables removeHaskellEnvVars :: Map Text Text -> Map Text Text removeHaskellEnvVars = Map.delete "GHCJS_PACKAGE_PATH" . Map.delete "GHC_PACKAGE_PATH" . Map.delete "HASKELL_PACKAGE_SANDBOX" . Map.delete "HASKELL_PACKAGE_SANDBOXES" . Map.delete "HASKELL_DIST_DIR" . -- https://github.com/commercialhaskell/stack/issues/1460 Map.delete "DESTDIR" . -- https://github.com/commercialhaskell/stack/issues/3444 Map.delete "GHCRTS" -- | Get map of environment variables to set to change the GHC's encoding to UTF-8 getUtf8EnvVars :: (HasProcessContext env, HasPlatform env, HasLogFunc env) => CompilerVersion 'CVActual -> RIO env (Map Text Text) getUtf8EnvVars compilerVer = if getGhcVersion compilerVer >= $(mkVersion "7.10.3") -- GHC_CHARENC supported by GHC >=7.10.3 then return $ Map.singleton "GHC_CHARENC" "UTF-8" else legacyLocale where legacyLocale = do menv <- view processContextL Platform _ os <- view platformL if os == Cabal.Windows then -- On Windows, locale is controlled by the code page, so we don't set any environment -- variables. return Map.empty else do let checkedVars = map checkVar (Map.toList $ view envVarsL menv) -- List of environment variables that will need to be updated to set UTF-8 (because -- they currently do not specify UTF-8). needChangeVars = concatMap fst checkedVars -- Set of locale-related environment variables that have already have a value. existingVarNames = Set.unions (map snd checkedVars) -- True if a locale is already specified by one of the "global" locale variables. hasAnyExisting = any (`Set.member` existingVarNames) ["LANG", "LANGUAGE", "LC_ALL"] if null needChangeVars && hasAnyExisting then -- If no variables need changes and at least one "global" variable is set, no -- changes to environment need to be made. return Map.empty else do -- Get a list of known locales by running @locale -a@. elocales <- tryAny $ fmap fst $ proc "locale" ["-a"] readProcess_ let -- Filter the list to only include locales with UTF-8 encoding. utf8Locales = case elocales of Left _ -> [] Right locales -> filter isUtf8Locale (T.lines $ T.decodeUtf8With T.lenientDecode $ LBS.toStrict locales) mfallback = getFallbackLocale utf8Locales when (isNothing mfallback) (logWarn "Warning: unable to set locale to UTF-8 encoding; GHC may fail with 'invalid character'") let -- Get the new values of variables to adjust. changes = Map.unions $ map (adjustedVarValue menv utf8Locales mfallback) needChangeVars -- Get the values of variables to add. adds | hasAnyExisting = -- If we already have a "global" variable, then nothing needs -- to be added. Map.empty | otherwise = -- If we don't already have a "global" variable, then set LANG to the -- fallback. case mfallback of Nothing -> Map.empty Just fallback -> Map.singleton "LANG" fallback return (Map.union changes adds) -- Determines whether an environment variable is locale-related and, if so, whether it needs to -- be adjusted. checkVar :: (Text, Text) -> ([Text], Set Text) checkVar (k,v) = if k `elem` ["LANG", "LANGUAGE"] || "LC_" `T.isPrefixOf` k then if isUtf8Locale v then ([], Set.singleton k) else ([k], Set.singleton k) else ([], Set.empty) -- Adjusted value of an existing locale variable. Looks for valid UTF-8 encodings with -- same language /and/ territory, then with same language, and finally the first UTF-8 locale -- returned by @locale -a@. adjustedVarValue :: ProcessContext -> [Text] -> Maybe Text -> Text -> Map Text Text adjustedVarValue menv utf8Locales mfallback k = case Map.lookup k (view envVarsL menv) of Nothing -> Map.empty Just v -> case concatMap (matchingLocales utf8Locales) [ T.takeWhile (/= '.') v <> "." , T.takeWhile (/= '_') v <> "_"] of (v':_) -> Map.singleton k v' [] -> case mfallback of Just fallback -> Map.singleton k fallback Nothing -> Map.empty -- Determine the fallback locale, by looking for any UTF-8 locale prefixed with the list in -- @fallbackPrefixes@, and if not found, picking the first UTF-8 encoding returned by @locale -- -a@. getFallbackLocale :: [Text] -> Maybe Text getFallbackLocale utf8Locales = case concatMap (matchingLocales utf8Locales) fallbackPrefixes of (v:_) -> Just v [] -> case utf8Locales of [] -> Nothing (v:_) -> Just v -- Filter the list of locales for any with the given prefixes (case-insitive). matchingLocales :: [Text] -> Text -> [Text] matchingLocales utf8Locales prefix = filter (\v -> T.toLower prefix `T.isPrefixOf` T.toLower v) utf8Locales -- Does the locale have one of the encodings in @utf8Suffixes@ (case-insensitive)? isUtf8Locale locale = any (\ v -> T.toLower v `T.isSuffixOf` T.toLower locale) utf8Suffixes -- Prefixes of fallback locales (case-insensitive) fallbackPrefixes = ["C.", "en_US.", "en_"] -- Suffixes of UTF-8 locales (case-insensitive) utf8Suffixes = [".UTF-8", ".utf8"] -- Binary Stack upgrades newtype StackReleaseInfo = StackReleaseInfo Value downloadStackReleaseInfo :: (MonadIO m, MonadThrow m) => Maybe String -- Github org -> Maybe String -- Github repo -> Maybe String -- ^ optional version -> m StackReleaseInfo downloadStackReleaseInfo morg mrepo mver = liftIO $ do let org = fromMaybe "commercialhaskell" morg repo = fromMaybe "stack" mrepo let url = concat [ "https://api.github.com/repos/" , org , "/" , repo , "/releases/" , case mver of Nothing -> "latest" Just ver -> "tags/v" ++ ver ] req <- parseRequest url res <- httpJSON $ setGithubHeaders req let code = getResponseStatusCode res if code >= 200 && code < 300 then return $ StackReleaseInfo $ getResponseBody res else throwString $ "Could not get release information for Stack from: " ++ url preferredPlatforms :: (MonadReader env m, HasPlatform env, MonadThrow m) => m [(Bool, String)] preferredPlatforms = do Platform arch' os' <- view platformL (isWindows, os) <- case os' of Cabal.Linux -> return (False, "linux") Cabal.Windows -> return (True, "windows") Cabal.OSX -> return (False, "osx") Cabal.FreeBSD -> return (False, "freebsd") _ -> throwM $ stringException $ "Binary upgrade not yet supported on OS: " ++ show os' arch <- case arch' of I386 -> return "i386" X86_64 -> return "x86_64" Arm -> return "arm" _ -> throwM $ stringException $ "Binary upgrade not yet supported on arch: " ++ show arch' hasgmp4 <- return False -- FIXME import relevant code from Stack.Setup? checkLib $(mkRelFile "libgmp.so.3") let suffixes | hasgmp4 = ["-static", "-gmp4", ""] | otherwise = ["-static", ""] return $ map (\suffix -> (isWindows, concat [os, "-", arch, suffix])) suffixes downloadStackExe :: HasConfig env => [(Bool, String)] -- ^ acceptable platforms -> StackReleaseInfo -> Path Abs Dir -- ^ destination directory -> Bool -- ^ perform PATH-aware checking, see #3232 -> (Path Abs File -> IO ()) -- ^ test the temp exe before renaming -> RIO env () downloadStackExe platforms0 archiveInfo destDir checkPath testExe = do (isWindows, archiveURL) <- let loop [] = throwString $ "Unable to find binary Stack archive for platforms: " ++ unwords (map snd platforms0) loop ((isWindows, p'):ps) = do let p = T.pack p' logInfo $ "Querying for archive location for platform: " <> fromString p' case findArchive archiveInfo p of Just x -> return (isWindows, x) Nothing -> loop ps in loop platforms0 let (destFile, tmpFile) | isWindows = ( destDir $(mkRelFile "stack.exe") , destDir $(mkRelFile "stack.tmp.exe") ) | otherwise = ( destDir $(mkRelFile "stack") , destDir $(mkRelFile "stack.tmp") ) logInfo $ "Downloading from: " <> RIO.display archiveURL liftIO $ do case () of () | ".tar.gz" `T.isSuffixOf` archiveURL -> handleTarball tmpFile isWindows archiveURL | ".zip" `T.isSuffixOf` archiveURL -> error "FIXME: Handle zip files" | otherwise -> error $ "Unknown archive format for Stack archive: " ++ T.unpack archiveURL logInfo "Download complete, testing executable" platform <- view platformL liftIO $ do #if !WINDOWS setFileMode (toFilePath tmpFile) 0o755 #endif testExe tmpFile currExe <- getExecutablePath case platform of Platform _ Cabal.Windows | FP.equalFilePath (toFilePath destFile) currExe -> do old <- parseAbsFile (toFilePath destFile ++ ".old") renameFile destFile old renameFile tmpFile destFile _ -> renameFile tmpFile destFile destDir' <- liftIO . D.canonicalizePath . toFilePath $ destDir warnInstallSearchPathIssues destDir' ["stack"] logInfo $ "New stack executable available at " <> fromString (toFilePath destFile) when checkPath $ performPathChecking destFile `catchAny` (logError . displayShow) where findArchive (StackReleaseInfo val) pattern = do Object top <- return val Array assets <- HashMap.lookup "assets" top getFirst $ fold $ fmap (First . findMatch pattern') assets where pattern' = mconcat ["-", pattern, "."] findMatch pattern'' (Object o) = do String name <- HashMap.lookup "name" o guard $ not $ ".asc" `T.isSuffixOf` name guard $ pattern'' `T.isInfixOf` name String url <- HashMap.lookup "browser_download_url" o Just url findMatch _ _ = Nothing handleTarball :: Path Abs File -> Bool -> T.Text -> IO () handleTarball tmpFile isWindows url = do req <- fmap setGithubHeaders $ parseUrlThrow $ T.unpack url withResponse req $ \res -> do entries <- fmap (Tar.read . LBS.fromChunks) $ lazyConsume $ getResponseBody res .| ungzip let loop Tar.Done = error $ concat [ "Stack executable " , show exeName , " not found in archive from " , T.unpack url ] loop (Tar.Fail e) = throwM e loop (Tar.Next e es) | Tar.entryPath e == exeName = case Tar.entryContent e of Tar.NormalFile lbs _ -> do ensureDir destDir LBS.writeFile (toFilePath tmpFile) lbs _ -> error $ concat [ "Invalid file type for tar entry named " , exeName , " downloaded from " , T.unpack url ] | otherwise = loop es loop entries where -- The takeBaseName drops the .gz, dropExtension drops the .tar exeName = let base = FP.dropExtension (FP.takeBaseName (T.unpack url)) FP. "stack" in if isWindows then base FP.<.> "exe" else base -- | Ensure that the Stack executable download is in the same location -- as the currently running executable. See: -- https://github.com/commercialhaskell/stack/issues/3232 performPathChecking :: HasConfig env => Path Abs File -- ^ location of the newly downloaded file -> RIO env () performPathChecking newFile = do executablePath <- liftIO getExecutablePath executablePath' <- parseAbsFile executablePath unless (toFilePath newFile == executablePath) $ do logInfo $ "Also copying stack executable to " <> fromString executablePath tmpFile <- parseAbsFile $ executablePath ++ ".tmp" eres <- tryIO $ do liftIO $ copyFile newFile tmpFile #if !WINDOWS liftIO $ setFileMode (toFilePath tmpFile) 0o755 #endif liftIO $ renameFile tmpFile executablePath' logInfo "Stack executable copied successfully!" case eres of Right () -> return () Left e | isPermissionError e -> do logWarn $ "Permission error when trying to copy: " <> displayShow e logWarn "Should I try to perform the file copy using sudo? This may fail" toSudo <- promptBool "Try using sudo? (y/n) " when toSudo $ do let run cmd args = do ec <- proc cmd args runProcess when (ec /= ExitSuccess) $ error $ concat [ "Process exited with " , show ec , ": " , unwords (cmd:args) ] commands = [ ("sudo", [ "cp" , toFilePath newFile , toFilePath tmpFile ]) , ("sudo", [ "mv" , toFilePath tmpFile , executablePath ]) ] logInfo "Going to run the following commands:" logInfo "" forM_ commands $ \(cmd, args) -> logInfo $ "- " <> mconcat (intersperse " " (fromString <$> (cmd:args))) mapM_ (uncurry run) commands logInfo "" logInfo "sudo file copy worked!" | otherwise -> throwM e getDownloadVersion :: StackReleaseInfo -> Maybe Version getDownloadVersion (StackReleaseInfo val) = do Object o <- Just val String rawName <- HashMap.lookup "name" o -- drop the "v" at the beginning of the name parseVersion $ T.drop 1 rawName stack-1.9.3.1/src/Stack/Setup/Installed.hs0000644000000000000000000001674113455617610016406 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude #-} {-# LANGUAGE ConstraintKinds #-} {-# LANGUAGE DataKinds #-} {-# LANGUAGE DeriveGeneric #-} {-# LANGUAGE FlexibleContexts #-} {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TemplateHaskell #-} {-# LANGUAGE ViewPatterns #-} {-# LANGUAGE LambdaCase #-} module Stack.Setup.Installed ( getCompilerVersion , markInstalled , unmarkInstalled , listInstalled , Tool (..) , toolString , toolNameString , parseToolText , ExtraDirs (..) , extraDirs , installDir , tempInstallDir ) where import Stack.Prelude import qualified Data.ByteString as B import qualified Data.ByteString.Char8 as S8 import qualified Data.ByteString.Lazy as BL import Data.List hiding (concat, elem, maximumBy) import qualified Data.Text as T import qualified Data.Text.Encoding as T import Distribution.System (Platform (..)) import qualified Distribution.System as Cabal import Generics.Deriving.Monoid (mappenddefault, memptydefault) import Path import Path.IO import Stack.Types.Compiler import Stack.Types.Config import Stack.Types.PackageIdentifier import Stack.Types.PackageName import Stack.Types.Version import RIO.Process data Tool = Tool PackageIdentifier -- ^ e.g. ghc-7.8.4, msys2-20150512 | ToolGhcjs (CompilerVersion 'CVActual) -- ^ e.g. ghcjs-0.1.0_ghc-7.10.2 toolString :: Tool -> String toolString (Tool ident) = packageIdentifierString ident toolString (ToolGhcjs cv) = compilerVersionString cv toolNameString :: Tool -> String toolNameString (Tool ident) = packageNameString $ packageIdentifierName ident toolNameString ToolGhcjs{} = "ghcjs" parseToolText :: Text -> Maybe Tool parseToolText (parseCompilerVersion -> Just cv@GhcjsVersion{}) = Just (ToolGhcjs cv) parseToolText (parsePackageIdentifierFromString . T.unpack -> Just pkgId) = Just (Tool pkgId) parseToolText _ = Nothing markInstalled :: (MonadIO m, MonadThrow m) => Path Abs Dir -> Tool -> m () markInstalled programsPath tool = do fpRel <- parseRelFile $ toolString tool ++ ".installed" liftIO $ B.writeFile (toFilePath $ programsPath fpRel) "installed" unmarkInstalled :: MonadIO m => Path Abs Dir -> Tool -> m () unmarkInstalled programsPath tool = liftIO $ do fpRel <- parseRelFile $ toolString tool ++ ".installed" ignoringAbsence (removeFile $ programsPath fpRel) listInstalled :: (MonadIO m, MonadThrow m) => Path Abs Dir -> m [Tool] listInstalled programsPath = do doesDirExist programsPath >>= \case False -> return [] True -> do (_, files) <- listDir programsPath return $ mapMaybe toTool files where toTool fp = do x <- T.stripSuffix ".installed" $ T.pack $ toFilePath $ filename fp parseToolText x -- | See https://github.com/commercialhaskell/stack/issues/4086. warnAboutGHCJS :: HasLogFunc env => RIO env () warnAboutGHCJS = logWarn $ "Building a GHCJS project. " <> fromString ghcjsWarning ghcjsWarning :: String ghcjsWarning = unwords [ "Note that GHCJS support in Stack is EXPERIMENTAL" ] getCompilerVersion :: (HasProcessContext env, HasLogFunc env) => WhichCompiler -> RIO env (CompilerVersion 'CVActual) getCompilerVersion wc = case wc of Ghc -> do logDebug "Asking GHC for its version" bs <- fst <$> proc "ghc" ["--numeric-version"] readProcess_ let (_, ghcVersion) = versionFromEnd $ BL.toStrict bs x <- GhcVersion <$> parseVersion (T.decodeUtf8 ghcVersion) logDebug $ "GHC version is: " <> display x return x Ghcjs -> do warnAboutGHCJS logDebug "Asking GHCJS for its version" -- Output looks like -- -- The Glorious Glasgow Haskell Compilation System for JavaScript, version 0.1.0 (GHC 7.10.2) bs <- fst <$> proc "ghcjs" ["--version"] readProcess_ let (rest, ghcVersion) = T.decodeUtf8 <$> versionFromEnd (BL.toStrict bs) (_, ghcjsVersion) = T.decodeUtf8 <$> versionFromEnd rest GhcjsVersion <$> parseVersion ghcjsVersion <*> parseVersion ghcVersion where versionFromEnd = S8.spanEnd isValid . fst . S8.breakEnd isValid isValid c = c == '.' || ('0' <= c && c <= '9') -- | Binary directories for the given installed package extraDirs :: HasConfig env => Tool -> RIO env ExtraDirs extraDirs tool = do config <- view configL dir <- installDir (configLocalPrograms config) tool case (configPlatform config, toolNameString tool) of (Platform _ Cabal.Windows, isGHC -> True) -> return mempty { edBins = [ dir $(mkRelDir "bin") , dir $(mkRelDir "mingw") $(mkRelDir "bin") ] } (Platform Cabal.I386 Cabal.Windows, "msys2") -> return mempty { edBins = [ dir $(mkRelDir "mingw32") $(mkRelDir "bin") , dir $(mkRelDir "usr") $(mkRelDir "bin") , dir $(mkRelDir "usr") $(mkRelDir "local") $(mkRelDir "bin") ] , edInclude = [ dir $(mkRelDir "mingw32") $(mkRelDir "include") ] , edLib = [ dir $(mkRelDir "mingw32") $(mkRelDir "lib") , dir $(mkRelDir "mingw32") $(mkRelDir "bin") ] } (Platform Cabal.X86_64 Cabal.Windows, "msys2") -> return mempty { edBins = [ dir $(mkRelDir "mingw64") $(mkRelDir "bin") , dir $(mkRelDir "usr") $(mkRelDir "bin") , dir $(mkRelDir "usr") $(mkRelDir "local") $(mkRelDir "bin") ] , edInclude = [ dir $(mkRelDir "mingw64") $(mkRelDir "include") ] , edLib = [ dir $(mkRelDir "mingw64") $(mkRelDir "lib") , dir $(mkRelDir "mingw64") $(mkRelDir "bin") ] } (_, isGHC -> True) -> return mempty { edBins = [ dir $(mkRelDir "bin") ] } (_, isGHCJS -> True) -> return mempty { edBins = [ dir $(mkRelDir "bin") ] } (Platform _ x, toolName) -> do logWarn $ "binDirs: unexpected OS/tool combo: " <> displayShow (x, toolName) return mempty where isGHC n = "ghc" == n || "ghc-" `isPrefixOf` n isGHCJS n = "ghcjs" == n data ExtraDirs = ExtraDirs { edBins :: ![Path Abs Dir] , edInclude :: ![Path Abs Dir] , edLib :: ![Path Abs Dir] } deriving (Show, Generic) instance Semigroup ExtraDirs where (<>) = mappenddefault instance Monoid ExtraDirs where mempty = memptydefault mappend = (<>) installDir :: (MonadReader env m, MonadThrow m) => Path Abs Dir -> Tool -> m (Path Abs Dir) installDir programsDir tool = do relativeDir <- parseRelDir $ toolString tool return $ programsDir relativeDir tempInstallDir :: (MonadReader env m, MonadThrow m) => Path Abs Dir -> Tool -> m (Path Abs Dir) tempInstallDir programsDir tool = do relativeDir <- parseRelDir $ toolString tool ++ ".temp" return $ programsDir relativeDir stack-1.9.3.1/src/Stack/SetupCmd.hs0000644000000000000000000001217713455617610015112 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude #-} {-# LANGUAGE ConstraintKinds #-} {-# LANGUAGE DataKinds #-} {-# LANGUAGE FlexibleContexts #-} {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE RecordWildCards #-} -- | Install GHC/GHCJS and Cabal. module Stack.SetupCmd ( setup , setupParser , SetupCmdOpts(..) ) where import Control.Applicative import Control.Monad.Logger () import Control.Monad.Reader import qualified Data.Text as T import qualified Options.Applicative as OA import qualified Options.Applicative.Builder.Extra as OA import qualified Options.Applicative.Types as OA import Path import Stack.Prelude import Stack.Setup import Stack.Types.Compiler import Stack.Types.Config import Stack.Types.Version data SetupCmdOpts = SetupCmdOpts { scoCompilerVersion :: !(Maybe (CompilerVersion 'CVWanted)) , scoForceReinstall :: !Bool , scoUpgradeCabal :: !(Maybe UpgradeTo) , scoSetupInfoYaml :: !String , scoGHCBindistURL :: !(Maybe String) , scoGHCJSBootOpts :: ![String] , scoGHCJSBootClean :: !Bool } setupYamlCompatParser :: OA.Parser String setupYamlCompatParser = stackSetupYaml <|> setupInfoYaml where stackSetupYaml = OA.strOption ( OA.long "stack-setup-yaml" <> OA.help "DEPRECATED: Use 'setup-info-yaml' instead" <> OA.metavar "URL" <> OA.hidden ) setupInfoYaml = OA.strOption ( OA.long "setup-info-yaml" <> OA.help "Alternate URL or absolute path for stack dependencies" <> OA.metavar "URL" <> OA.value defaultSetupInfoYaml ) cabalUpgradeParser :: OA.Parser UpgradeTo cabalUpgradeParser = Specific <$> version' <|> latestParser where versionReader = do s <- OA.readerAsk case parseVersion (T.pack s) of Nothing -> OA.readerError $ "Invalid version: " ++ s Just v -> return v version' = OA.option versionReader ( OA.long "install-cabal" <> OA.metavar "VERSION" <> OA.help "Install a specific version of Cabal" ) latestParser = OA.flag' Latest ( OA.long "upgrade-cabal" <> OA.help "DEPRECATED Install latest version of Cabal globally" ) setupParser :: OA.Parser SetupCmdOpts setupParser = SetupCmdOpts <$> OA.optional (OA.argument readVersion (OA.metavar "GHC_VERSION" <> OA.help ("Version of GHC to install, e.g. 7.10.2. " ++ "The default is to install the version implied by the resolver."))) <*> OA.boolFlags False "reinstall" "reinstalling GHC, even if available (incompatible with --system-ghc)" OA.idm <*> OA.optional cabalUpgradeParser <*> setupYamlCompatParser <*> OA.optional (OA.strOption (OA.long "ghc-bindist" <> OA.metavar "URL" <> OA.help "Alternate GHC binary distribution (requires custom --ghc-variant)")) <*> OA.many (OA.strOption (OA.long "ghcjs-boot-options" <> OA.metavar "GHCJS_BOOT" <> OA.help "Additional ghcjs-boot options")) <*> OA.boolFlags True "ghcjs-boot-clean" "Control if ghcjs-boot should have --clean option present" OA.idm where readVersion = do s <- OA.readerAsk case parseCompilerVersion ("ghc-" <> T.pack s) of Nothing -> case parseCompilerVersion (T.pack s) of Nothing -> OA.readerError $ "Invalid version: " ++ s Just x -> return x Just x -> return x setup :: (HasConfig env, HasGHCVariant env) => SetupCmdOpts -> CompilerVersion 'CVWanted -> VersionCheck -> Maybe (Path Abs File) -> RIO env () setup SetupCmdOpts{..} wantedCompiler compilerCheck mstack = do Config{..} <- view configL (_, _, sandboxedGhc) <- ensureCompiler SetupOpts { soptsInstallIfMissing = True , soptsUseSystem = configSystemGHC && not scoForceReinstall , soptsWantedCompiler = wantedCompiler , soptsCompilerCheck = compilerCheck , soptsStackYaml = mstack , soptsForceReinstall = scoForceReinstall , soptsSanityCheck = True , soptsSkipGhcCheck = False , soptsSkipMsys = configSkipMsys , soptsUpgradeCabal = scoUpgradeCabal , soptsResolveMissingGHC = Nothing , soptsSetupInfoYaml = scoSetupInfoYaml , soptsGHCBindistURL = scoGHCBindistURL , soptsGHCJSBootOpts = scoGHCJSBootOpts ++ ["--clean" | scoGHCJSBootClean] } let compiler = case wantedCompiler of GhcVersion _ -> "GHC" GhcjsVersion {} -> "GHCJS" if sandboxedGhc then logInfo $ "stack will use a sandboxed " <> compiler <> " it installed" else logInfo $ "stack will use the " <> compiler <> " on your PATH" logInfo "For more information on paths, see 'stack path' and 'stack exec env'" logInfo $ "To use this " <> compiler <> " and packages outside of a project, consider using:" logInfo "stack ghc, stack ghci, stack runghc, or stack exec" stack-1.9.3.1/src/Stack/Sig.hs0000644000000000000000000000055213455666157014114 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude #-} {-| Module : Stack.Sig Description : GPG Signatures for Stack Copyright : (c) 2015-2018, Stack contributors License : BSD3 Maintainer : Tim Dysinger Stability : experimental Portability : POSIX -} module Stack.Sig (module Sig) where import Stack.Sig.GPG as Sig import Stack.Sig.Sign as Sig stack-1.9.3.1/src/Stack/Sig/GPG.hs0000644000000000000000000000715213455666157014534 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude #-} {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE RankNTypes #-} {-| Module : Stack.Sig.GPG Description : GPG Functions Copyright : (c) 2015-2018, Stack contributors License : BSD3 Maintainer : Tim Dysinger Stability : experimental Portability : POSIX -} module Stack.Sig.GPG (gpgSign, gpgVerify) where import Stack.Prelude import qualified Data.ByteString.Char8 as C import Data.List (find, isPrefixOf) import qualified Data.Text as T import Stack.Types.Sig import System.Directory (findExecutable) import System.Environment (lookupEnv) import System.Exit (ExitCode(..)) import System.IO (hGetContents, hPutStrLn) import System.Info (os) import System.Process (ProcessHandle, runInteractiveProcess, waitForProcess) -- | Sign a file path with GPG, returning the @Signature@. gpgSign :: HasLogFunc env => Path Abs File -> RIO env Signature gpgSign path = do gpgWarnTTY (_hIn,hOut,hErr,process) <- gpg [ "--output" , "-" , "--use-agent" , "--detach-sig" , "--armor" , toFilePath path] (out,err,code) <- liftIO ((,,) <$> hGetContents hOut <*> hGetContents hErr <*> waitForProcess process) if code /= ExitSuccess then throwM (GPGSignException $ out <> "\n" <> err) else return (Signature $ C.pack out) -- | Verify the @Signature@ of a file path returning the -- @Fingerprint@. gpgVerify :: (MonadIO m, MonadThrow m) => Signature -> Path Abs File -> m Fingerprint gpgVerify (Signature signature) path = do (hIn,hOut,hErr,process) <- gpg ["--verify", "--with-fingerprint", "-", toFilePath path] (_in,out,err,code) <- liftIO ((,,,) <$> hPutStrLn hIn (C.unpack signature) <*> hGetContents hOut <*> hGetContents hErr <*> waitForProcess process) if code /= ExitSuccess then throwM (GPGVerifyException (out ++ "\n" ++ err)) else maybe (throwM (GPGFingerprintException ("unable to extract fingerprint from output\n: " <> out))) return (mkFingerprint . T.pack . concat . drop 3 <$> find ((==) ["Primary", "key", "fingerprint:"] . take 3) (map words (lines err))) -- | Try to execute `gpg2` but fallback to `gpg` (as a backup) gpg :: (MonadIO m, MonadThrow m) => [String] -> m (Handle, Handle, Handle, ProcessHandle) gpg args = do mGpg2Path <- liftIO (findExecutable "gpg2") case mGpg2Path of Just _ -> liftIO (runInteractiveProcess "gpg2" args Nothing Nothing) Nothing -> do mGpgPath <- liftIO (findExecutable "gpg") case mGpgPath of Just _ -> liftIO (runInteractiveProcess "gpg" args Nothing Nothing) Nothing -> throwM GPGNotFoundException -- | `man gpg-agent` shows that you need GPG_TTY environment variable set to -- properly deal with interactions with gpg-agent. (Doesn't apply to Windows -- though) gpgWarnTTY :: HasLogFunc env => RIO env () gpgWarnTTY = unless ("ming" `isPrefixOf` os) (do mTTY <- liftIO (lookupEnv "GPG_TTY") when (null mTTY) (logWarn "Environment variable GPG_TTY is not set (see `man gpg-agent`)")) stack-1.9.3.1/src/Stack/Sig/Sign.hs0000644000000000000000000001025313455666157015013 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude #-} {-# LANGUAGE CPP #-} {-# LANGUAGE FlexibleContexts #-} {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE RankNTypes #-} {-| Module : Stack.Sig.Sign Description : Signing Packages Copyright : (c) 2015-2018, Stack contributors License : BSD3 Maintainer : Tim Dysinger Stability : experimental Portability : POSIX -} module Stack.Sig.Sign (sign, signPackage, signTarBytes) where import qualified Codec.Archive.Tar as Tar import qualified Codec.Compression.GZip as GZip import Stack.Prelude import qualified Data.ByteString.Lazy as BS import qualified Data.ByteString.Lazy as L import Network.HTTP.Download import Network.HTTP.StackClient (RequestBody (RequestBodyBS), setRequestMethod, setRequestBody, getResponseStatusCode, methodPut) import Path import Stack.Package import Stack.Sig.GPG import Stack.Types.PackageIdentifier import Stack.Types.Sig import qualified System.FilePath as FP -- | Sign a haskell package with the given url of the signature -- service and a path to a tarball. sign :: HasLogFunc env => String -> Path Abs File -> RIO env Signature sign url filePath = withRunInIO $ \run -> withSystemTempDir "stack" (\tempDir -> do bytes <- liftIO (fmap GZip.decompress (BS.readFile (toFilePath filePath))) maybePath <- extractCabalFile tempDir (Tar.read bytes) case maybePath of Nothing -> throwM SigInvalidSDistTarBall Just cabalPath -> do pkg <- cabalFilePackageId (tempDir cabalPath) run (signPackage url pkg filePath)) where extractCabalFile tempDir (Tar.Next entry entries) = case Tar.entryContent entry of (Tar.NormalFile lbs _) -> case FP.splitFileName (Tar.entryPath entry) of (folder,file) | length (FP.splitDirectories folder) == 1 && FP.takeExtension file == ".cabal" -> do cabalFile <- parseRelFile file liftIO (BS.writeFile (toFilePath (tempDir cabalFile)) lbs) return (Just cabalFile) (_,_) -> extractCabalFile tempDir entries _ -> extractCabalFile tempDir entries extractCabalFile _ _ = return Nothing -- | Sign a haskell package with the given url to the signature -- service, a package tarball path (package tarball name) and a lazy -- bytestring of bytes that represent the tarball bytestream. The -- function will write the bytes to the path in a temp dir and sign -- the tarball with GPG. signTarBytes :: HasLogFunc env => String -> Path Rel File -> L.ByteString -> RIO env Signature signTarBytes url tarPath bs = withSystemTempDir "stack" (\tempDir -> do let tempTarBall = tempDir tarPath liftIO (L.writeFile (toFilePath tempTarBall) bs) sign url tempTarBall) -- | Sign a haskell package given the url to the signature service, a -- @PackageIdentifier@ and a file path to the package on disk. signPackage :: HasLogFunc env => String -> PackageIdentifier -> Path Abs File -> RIO env Signature signPackage url pkg filePath = do sig@(Signature signature) <- gpgSign filePath let (PackageIdentifier name version) = pkg fingerprint <- gpgVerify sig filePath let fullUrl = url <> "/upload/signature/" <> show name <> "/" <> show version <> "/" <> show fingerprint req <- parseUrlThrow fullUrl let put = setRequestMethod methodPut $ setRequestBody (RequestBodyBS signature) req res <- liftIO (httpLbs put) when (getResponseStatusCode res /= 200) (throwM (GPGSignException "unable to sign & upload package")) logInfo ("Signature uploaded to " <> fromString fullUrl) return sig stack-1.9.3.1/src/Stack/Snapshot.hs0000644000000000000000000010435413455617610015164 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude #-} {-# LANGUAGE ConstraintKinds #-} {-# LANGUAGE DataKinds #-} {-# LANGUAGE DeriveDataTypeable #-} {-# LANGUAGE DeriveGeneric #-} {-# LANGUAGE EmptyDataDecls #-} {-# LANGUAGE FlexibleContexts #-} {-# LANGUAGE GADTs #-} {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE RecordWildCards #-} {-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE TemplateHaskell #-} {-# LANGUAGE TupleSections #-} {-# LANGUAGE ViewPatterns #-} -- | Reading in @SnapshotDef@s and converting them into -- @LoadedSnapshot@s. module Stack.Snapshot ( loadResolver , loadSnapshot , calculatePackagePromotion ) where import Stack.Prelude hiding (Display (..)) import Control.Monad.State.Strict (get, put, StateT, execStateT) import Crypto.Hash.Conduit (hashFile) import Data.Aeson (withObject, (.!=), (.:), (.:?), Value (Object)) import Data.Aeson.Extended (WithJSONWarnings(..), logJSONWarnings, (..!=), (..:?), jsonSubWarningsT, withObjectWarnings, (..:)) import Data.Aeson.Types (Parser, parseEither) import Data.Store.VersionTagged import qualified Data.Conduit.List as CL import qualified Data.HashMap.Strict as HashMap import qualified Data.Map as Map import qualified Data.Set as Set import Data.Time (toGregorian) import qualified Data.Text as T import Data.Text.Encoding (encodeUtf8) import Data.Yaml (decodeFileEither, ParseException (AesonException)) import Distribution.InstalledPackageInfo (PError) import Distribution.PackageDescription (GenericPackageDescription) import qualified Distribution.PackageDescription as C import Distribution.System (Platform) import Distribution.Text (display) import qualified Distribution.Version as C import Network.HTTP.StackClient (Request) import Network.HTTP.Download import qualified RIO import Network.URI (isURI) import Path import Path.IO import Stack.Constants import Stack.Package import Stack.PackageDump import Stack.PackageLocation import Stack.Types.BuildPlan import Stack.Types.FlagName import Stack.Types.GhcPkgId import Stack.Types.PackageIdentifier import Stack.Types.PackageName import Stack.Types.Version import Stack.Types.VersionIntervals import Stack.Types.Config import Stack.Types.Urls import Stack.Types.Compiler import Stack.Types.Resolver import qualified System.Directory as Dir import qualified System.FilePath as FilePath type SinglePackageLocation = PackageLocationIndex FilePath data SnapshotException = InvalidCabalFileInSnapshot !SinglePackageLocation !PError | PackageDefinedTwice !PackageName !SinglePackageLocation !SinglePackageLocation | UnmetDeps !(Map PackageName (Map PackageName (VersionIntervals, Maybe Version))) | FilepathInCustomSnapshot !Text | NeedResolverOrCompiler !Text | MissingPackages !(Set PackageName) | CustomResolverException !Text !(Either Request FilePath) !ParseException | InvalidStackageException !SnapName !String deriving Typeable instance Exception SnapshotException instance Show SnapshotException where show (InvalidCabalFileInSnapshot loc err) = concat [ "Invalid cabal file at " , show loc , ": " , show err ] show (PackageDefinedTwice name loc1 loc2) = concat [ "Package " , packageNameString name , " is defined twice, at " , show loc1 , " and " , show loc2 ] show (UnmetDeps m) = concat $ "Some dependencies in the snapshot are unmet.\n" : map go (Map.toList m) where go (name, deps) = concat $ "\n" : packageNameString name : " is missing:\n" : map goDep (Map.toList deps) goDep (dep, (intervals, mversion)) = concat [ "- " , packageNameString dep , ". Requires: " , display $ toVersionRange intervals , ", " , case mversion of Nothing -> "none present" Just version -> versionString version ++ " found" , "\n" ] show (FilepathInCustomSnapshot url) = "Custom snapshots do not support filepaths, as the contents may change over time. Found in: " ++ T.unpack url show (NeedResolverOrCompiler url) = "You must specify either a resolver or compiler value in " ++ T.unpack url show (MissingPackages names) = "The following packages specified by flags or options are not found: " ++ unwords (map packageNameString (Set.toList names)) show (CustomResolverException url loc e) = concat [ "Unable to load custom resolver " , T.unpack url , " from " , case loc of Left _req -> "HTTP request" Right fp -> "local file:\n " ++ fp , "\nException: " , case e of AesonException s -> s _ -> show e ] show (InvalidStackageException snapName e) = concat [ "Unable to parse Stackage snapshot " , T.unpack (renderSnapName snapName) , ": " , e ] -- | Convert a 'Resolver' into a 'SnapshotDef' loadResolver :: forall env. HasConfig env => Resolver -> RIO env SnapshotDef loadResolver (ResolverStackage name) = do stackage <- view stackRootL file' <- parseRelFile $ T.unpack file cachePath <- (buildPlanCacheDir stackage ) <$> parseRelFile (T.unpack (renderSnapName name <> ".cache")) let fp = buildPlanDir stackage file' tryDecode = tryAny $ $(versionedDecodeOrLoad snapshotDefVC) cachePath $ liftIO $ do evalue <- decodeFileEither $ toFilePath fp case evalue of Left e -> throwIO e Right value -> case parseEither parseStackageSnapshot value of Left s -> throwIO $ InvalidStackageException name s Right x -> return x logDebug $ "Decoding build plan from: " <> fromString (toFilePath fp) eres <- tryDecode case eres of Right sd -> return sd Left e -> do logDebug $ "Decoding Stackage snapshot definition from file failed: " <> displayShow e ensureDir (parent fp) url <- buildBuildPlanUrl name file req <- parseRequest $ T.unpack url logSticky $ "Downloading " <> RIO.display name <> " build plan ..." logDebug $ "Downloading build plan from: " <> RIO.display url wasDownloaded <- redownload req fp if wasDownloaded then logStickyDone $ "Downloaded " <> RIO.display name <> " build plan." else logStickyDone $ "Skipped download of " <> RIO.display name <> " because its the stored entity tag matches the server version" tryDecode >>= either throwM return where file = renderSnapName name <> ".yaml" buildBuildPlanUrl :: (MonadReader env m, HasConfig env) => SnapName -> Text -> m Text buildBuildPlanUrl snapName file' = do urls <- view $ configL.to configUrls return $ case snapName of LTS _ _ -> urlsLtsBuildPlans urls <> "/" <> file' Nightly _ -> urlsNightlyBuildPlans urls <> "/" <> file' parseStackageSnapshot = withObject "StackageSnapshotDef" $ \o -> do Object si <- o .: "system-info" ghcVersion <- si .:? "ghc-version" compilerVersion <- si .:? "compiler-version" compilerVersion' <- case (ghcVersion, compilerVersion) of (Just _, Just _) -> fail "can't have both compiler-version and ghc-version fields" (Just ghc, _) -> return (GhcVersion ghc) (_, Just compiler) -> return compiler _ -> fail "expected field \"ghc-version\" or \"compiler-version\" not present" let sdParent = Left compilerVersion' sdGlobalHints <- si .: "core-packages" packages <- o .: "packages" (Endo mkLocs, sdFlags, sdHidden) <- fmap mconcat $ mapM (uncurry goPkg) $ Map.toList packages let sdLocations = mkLocs [] let sdGhcOptions = Map.empty -- Stackage snapshots do not allow setting GHC options -- Not dropping any packages in a Stackage snapshot let sdDropPackages = Set.empty let sdResolver = ResolverStackage name sdResolverName = renderSnapName name return SnapshotDef {..} where goPkg name' = withObject "StackagePackageDef" $ \o -> do version <- o .: "version" mcabalFileInfo <- o .:? "cabal-file-info" mcabalFileInfo' <- forM mcabalFileInfo $ \o' -> do msize <- Just <$> o' .: "size" cfiHashes <- o' .: "hashes" hash' <- case HashMap.lookup ("SHA256" :: Text) cfiHashes of Nothing -> fail "Could not find SHA256" Just shaText -> case mkCabalHashFromSHA256 shaText of Left e -> fail $ "Invalid SHA256: " ++ show e Right x -> return x return $ CFIHash msize hash' Object constraints <- o .: "constraints" flags <- constraints .: "flags" let flags' = Map.singleton name' flags hide <- constraints .:? "hide" .!= False let hide' = if hide then Map.singleton name' True else Map.empty let location = PLIndex $ PackageIdentifierRevision (PackageIdentifier name' version) (fromMaybe CFILatest mcabalFileInfo') return (Endo (location:), flags', hide') loadResolver (ResolverCompiler compiler) = return SnapshotDef { sdParent = Left compiler , sdResolver = ResolverCompiler compiler , sdResolverName = compilerVersionText compiler , sdLocations = [] , sdDropPackages = Set.empty , sdFlags = Map.empty , sdHidden = Map.empty , sdGhcOptions = Map.empty , sdGlobalHints = Map.empty } loadResolver (ResolverCustom url loc) = do logDebug $ "Loading " <> RIO.display url <> " build plan from " <> displayShow loc case loc of Left req -> download' req >>= load . toFilePath Right fp -> load fp where download' :: Request -> RIO env (Path Abs File) download' req = do let urlHash = T.unpack $ trimmedSnapshotHash $ snapshotHashFromBS $ encodeUtf8 url hashFP <- parseRelFile $ urlHash ++ ".yaml" customPlanDir <- getCustomPlanDir let cacheFP = customPlanDir $(mkRelDir "yaml") hashFP void (download req cacheFP :: RIO env Bool) return cacheFP getCustomPlanDir = do root <- view stackRootL return $ root $(mkRelDir "custom-plan") load :: FilePath -> RIO env SnapshotDef load fp = do let resolveLocalArchives sd = sd { sdLocations = resolveLocalArchive <$> sdLocations sd } resolveLocalArchive (PLOther (PLArchive archive)) = PLOther $ PLArchive $ archive { archiveUrl = T.pack $ resolveLocalFilePath (T.unpack $ archiveUrl archive) } resolveLocalArchive pl = pl resolveLocalFilePath path = if isURI path || FilePath.isAbsolute path then path else FilePath.dropFileName fp FilePath. FilePath.normalise path WithJSONWarnings (sd0, mparentResolver, mcompiler) warnings <- liftIO (decodeFileEither fp) >>= either (throwM . CustomResolverException url loc) (either (throwM . CustomResolverException url loc . AesonException) return . parseEither parseCustom) logJSONWarnings (T.unpack url) warnings forM_ (sdLocations sd0) $ \loc' -> case loc' of PLOther (PLFilePath _) -> throwM $ FilepathInCustomSnapshot url _ -> return () let sd0' = resolveLocalArchives sd0 -- The fp above may just be the download location for a URL, -- which we don't want to use. Instead, look back at loc from -- above. mdir <- case loc of Left _ -> return Nothing Right fp' -> Just . parent <$> liftIO (Dir.canonicalizePath fp' >>= parseAbsFile) -- Deal with the dual nature of the compiler key, which either -- means "use this compiler" or "override the compiler in the -- resolver" (parentResolver, overrideCompiler) <- case (mparentResolver, mcompiler) of (Nothing, Nothing) -> throwM $ NeedResolverOrCompiler url (Just parentResolver, Nothing) -> return (parentResolver, id) (Nothing, Just compiler) -> return (ResolverCompiler compiler, id) (Just parentResolver, Just compiler) -> return ( parentResolver , setCompilerVersion compiler ) parentResolver' <- parseCustomLocation mdir parentResolver -- Calculate the hash of the current file, and then combine it -- with parent hashes if necessary below. rawHash :: SnapshotHash <- snapshotHashFromDigest <$> hashFile fp :: RIO env SnapshotHash (parent', hash') <- case parentResolver' of ResolverCompiler cv -> return (Left cv, rawHash) -- just a small optimization _ -> do parent' :: SnapshotDef <- loadResolver (parentResolver' :: Resolver) :: RIO env SnapshotDef let hash' :: SnapshotHash hash' = combineHash rawHash $ case sdResolver parent' of ResolverStackage snapName -> snapNameToHash snapName ResolverCustom _ parentHash -> parentHash ResolverCompiler _ -> error "loadResolver: Received ResolverCompiler in impossible location" return (Right parent', hash') return $ overrideCompiler sd0' { sdParent = parent' , sdResolver = ResolverCustom url hash' } -- | Note that the 'sdParent' and 'sdResolver' fields returned -- here are bogus, and need to be replaced with information only -- available after further processing. parseCustom :: Value -> Parser (WithJSONWarnings (SnapshotDef, Maybe (ResolverWith ()), Maybe (CompilerVersion 'CVWanted))) parseCustom = withObjectWarnings "CustomSnapshot" $ \o -> (,,) <$> (SnapshotDef (Left (error "loadResolver")) (ResolverStackage (LTS 0 0)) <$> (o ..: "name") <*> jsonSubWarningsT (o ..:? "packages" ..!= []) <*> o ..:? "drop-packages" ..!= Set.empty <*> o ..:? "flags" ..!= Map.empty <*> o ..:? "hidden" ..!= Map.empty <*> o ..:? "ghc-options" ..!= Map.empty <*> o ..:? "global-hints" ..!= Map.empty) <*> (o ..:? "resolver") <*> (o ..:? "compiler") combineHash :: SnapshotHash -> SnapshotHash -> SnapshotHash combineHash x y = snapshotHashFromBS (snapshotHashToBS x <> snapshotHashToBS y) snapNameToHash :: SnapName -> SnapshotHash snapNameToHash = snapshotHashFromBS . encodeUtf8 . renderSnapName -- | Fully load up a 'SnapshotDef' into a 'LoadedSnapshot' loadSnapshot :: forall env. (HasConfig env, HasGHCVariant env) => Maybe (CompilerVersion 'CVActual) -- ^ installed GHC we should query; if none provided, use the global hints -> Path Abs Dir -- ^ project root, used for checking out necessary files -> SnapshotDef -> RIO env LoadedSnapshot loadSnapshot mcompiler root = start where start (snapshotDefFixes -> sd) = do path <- configLoadedSnapshotCache sd (maybe GISSnapshotHints GISCompiler mcompiler) $(versionedDecodeOrLoad loadedSnapshotVC) path (inner sd) inner :: SnapshotDef -> RIO env LoadedSnapshot inner sd = do ls0 <- case sdParent sd of Left cv -> case mcompiler of Nothing -> return LoadedSnapshot { lsCompilerVersion = wantedToActual cv , lsGlobals = fromGlobalHints $ sdGlobalHints sd , lsPackages = Map.empty } Just cv' -> loadCompiler cv' Right sd' -> start sd' gpds <- (concat <$> mapM (parseMultiCabalFilesIndex root) (sdLocations sd)) `onException` do logError "Unable to load cabal files for snapshot" case sdResolver sd of ResolverStackage name -> do stackRoot <- view stackRootL file <- parseRelFile $ T.unpack $ renderSnapName name <> ".yaml" let fp = buildPlanDir stackRoot file liftIO $ ignoringAbsence $ removeFile fp logError "" logError "----" logError $ "Deleting cached snapshot file: " <> fromString (toFilePath fp) logError "Recommendation: try running again. If this fails again, open an upstream issue at:" logError $ case name of LTS _ _ -> "https://github.com/fpco/lts-haskell/issues/new" Nightly _ -> "https://github.com/fpco/stackage-nightly/issues/new" logError "----" logError "" _ -> return () (globals, snapshot, locals) <- calculatePackagePromotion root ls0 (map (\(x, y) -> (x, y, ())) gpds) (sdFlags sd) (sdHidden sd) (sdGhcOptions sd) (sdDropPackages sd) return LoadedSnapshot { lsCompilerVersion = lsCompilerVersion ls0 , lsGlobals = globals -- When applying a snapshot on top of another one, we merge -- the two snapshots' packages together. , lsPackages = Map.union snapshot (Map.map (fmap fst) locals) } -- | Given information on a 'LoadedSnapshot' and a given set of -- additional packages and configuration values, calculates the new -- global and snapshot packages, as well as the new local packages. -- -- The new globals and snapshots must be a subset of the initial -- values. calculatePackagePromotion :: forall env localLocation. (HasConfig env, HasGHCVariant env) => Path Abs Dir -- ^ project root -> LoadedSnapshot -> [(GenericPackageDescription, SinglePackageLocation, localLocation)] -- ^ packages we want to add on top of this snapshot -> Map PackageName (Map FlagName Bool) -- ^ flags -> Map PackageName Bool -- ^ overrides whether a package should be registered hidden -> Map PackageName [Text] -- ^ GHC options -> Set PackageName -- ^ packages in the snapshot to drop -> RIO env ( Map PackageName (LoadedPackageInfo GhcPkgId) -- new globals , Map PackageName (LoadedPackageInfo SinglePackageLocation) -- new snapshot , Map PackageName (LoadedPackageInfo (SinglePackageLocation, Maybe localLocation)) -- new locals ) calculatePackagePromotion root (LoadedSnapshot compilerVersion globals0 parentPackages0) gpds flags0 hides0 options0 drops0 = do platform <- view platformL -- Hand out flags, hide, and GHC options to the newly added -- packages (packages1, flags, hide, ghcOptions) <- execStateT (mapM_ (findPackage platform compilerVersion) gpds) (Map.empty, flags0, hides0, options0) let -- We need to drop all packages from globals and parent -- packages that are either marked to be dropped, or -- included in the new packages. toDrop = Map.union (void packages1) (Map.fromSet (const ()) drops0) globals1 = Map.difference globals0 toDrop parentPackages1 = Map.difference parentPackages0 toDrop -- The set of all packages that need to be upgraded based on -- newly set flags, hide values, or GHC options toUpgrade = Set.unions [Map.keysSet flags, Map.keysSet hide, Map.keysSet ghcOptions] -- Perform a sanity check: ensure that all of the packages -- that need to be upgraded actually exist in the global or -- parent packages oldNames = Set.union (Map.keysSet globals1) (Map.keysSet parentPackages1) extraToUpgrade = Set.difference toUpgrade oldNames unless (Set.null extraToUpgrade) $ throwM $ MissingPackages extraToUpgrade let -- Split up the globals into those that are to be upgraded -- (no longer globals) and those that remain globals, based -- solely on the toUpgrade value (noLongerGlobals1, globals2) = Map.partitionWithKey (\name _ -> name `Set.member` toUpgrade) globals1 -- Further: now that we've removed a bunch of packages from -- globals, split out any packages whose dependencies are no -- longer met (globals3, noLongerGlobals2) = splitUnmetDeps Map.empty globals2 -- Put together the two split out groups of packages noLongerGlobals3 :: Map PackageName (LoadedPackageInfo SinglePackageLocation) noLongerGlobals3 = Map.mapWithKey globalToSnapshot (Map.union noLongerGlobals1 noLongerGlobals2) -- Now do the same thing with parent packages: take out the -- packages to be upgraded and then split out unmet -- dependencies. (noLongerParent1, parentPackages2) = Map.partitionWithKey (\name _ -> name `Set.member` toUpgrade) parentPackages1 (parentPackages3, noLongerParent2) = splitUnmetDeps (Map.map lpiVersion globals3) parentPackages2 noLongerParent3 = Map.union noLongerParent1 noLongerParent2 -- Everything split off from globals and parents will be upgraded... allToUpgrade = Map.union noLongerGlobals3 noLongerParent3 -- ... so recalculate based on new values upgraded <- fmap Map.fromList $ mapM (recalculate root compilerVersion flags hide ghcOptions) $ Map.toList allToUpgrade -- Could be nice to check snapshot early... but disabling -- because ConstructPlan gives much nicer error messages let packages2 = Map.unions [Map.map void upgraded, Map.map void packages1, Map.map void parentPackages3] allAvailable = Map.union (lpiVersion <$> globals3) (lpiVersion <$> packages2) when False $ checkDepsMet allAvailable packages2 unless (Map.null (globals3 `Map.difference` globals0)) (error "calculatePackagePromotion: subset invariant violated for globals") unless (Map.null (parentPackages3 `Map.difference` parentPackages0)) (error "calculatePackagePromotion: subset invariant violated for parents") return ( globals3 , parentPackages3 , Map.union (Map.map (fmap (, Nothing)) upgraded) (Map.map (fmap (second Just)) packages1) ) -- | Recalculate a 'LoadedPackageInfo' based on updates to flags, -- hide values, and GHC options. recalculate :: forall env. (HasConfig env, HasGHCVariant env) => Path Abs Dir -- ^ root -> CompilerVersion 'CVActual -> Map PackageName (Map FlagName Bool) -> Map PackageName Bool -- ^ hide? -> Map PackageName [Text] -- ^ GHC options -> (PackageName, LoadedPackageInfo SinglePackageLocation) -> RIO env (PackageName, LoadedPackageInfo SinglePackageLocation) recalculate root compilerVersion allFlags allHide allOptions (name, lpi0) = do let hide = fromMaybe (lpiHide lpi0) (Map.lookup name allHide) options = fromMaybe (lpiGhcOptions lpi0) (Map.lookup name allOptions) case Map.lookup name allFlags of Nothing -> return (name, lpi0 { lpiHide = hide, lpiGhcOptions = options }) -- optimization Just flags -> do let loc = lpiLocation lpi0 gpd <- parseSingleCabalFileIndex root loc platform <- view platformL let res@(name', lpi) = calculate gpd platform compilerVersion loc flags hide options unless (name == name' && lpiVersion lpi0 == lpiVersion lpi) $ error "recalculate invariant violated" return res fromGlobalHints :: Map PackageName (Maybe Version) -> Map PackageName (LoadedPackageInfo GhcPkgId) fromGlobalHints = Map.unions . map go . Map.toList where go (_, Nothing) = Map.empty go (name, Just ver) = Map.singleton name LoadedPackageInfo { lpiVersion = ver -- For global hint purposes, we only care about the -- version. All other fields are ignored when checking -- project compatibility. , lpiLocation = either impureThrow id $ parseGhcPkgId $ packageIdentifierText $ PackageIdentifier name ver , lpiFlags = Map.empty , lpiGhcOptions = [] , lpiPackageDeps = Map.empty , lpiExposedModules = Set.empty , lpiHide = False } -- | Ensure that all of the dependencies needed by this package -- are available in the given Map of packages. checkDepsMet :: MonadThrow m => Map PackageName Version -- ^ all available packages -> Map PackageName (LoadedPackageInfo localLocation) -> m () checkDepsMet available m | Map.null errs = return () | otherwise = throwM $ UnmetDeps errs where errs = foldMap (uncurry go) (Map.toList m) go :: PackageName -> LoadedPackageInfo loc -> Map PackageName (Map PackageName (VersionIntervals, Maybe Version)) go name lpi | Map.null errs' = Map.empty | otherwise = Map.singleton name errs' where errs' = foldMap (uncurry goDep) (Map.toList (lpiPackageDeps lpi)) goDep :: PackageName -> VersionIntervals -> Map PackageName (VersionIntervals, Maybe Version) goDep name intervals = case Map.lookup name available of Nothing -> Map.singleton name (intervals, Nothing) Just version | version `withinIntervals` intervals -> Map.empty | otherwise -> Map.singleton name (intervals, Just version) -- | Load a snapshot from the given compiler version, using just the -- information in the global package database. loadCompiler :: forall env. HasConfig env => CompilerVersion 'CVActual -> RIO env LoadedSnapshot loadCompiler cv = do m <- ghcPkgDump (whichCompiler cv) [] (conduitDumpPackage .| CL.foldMap (\dp -> Map.singleton (dpGhcPkgId dp) dp)) return LoadedSnapshot { lsCompilerVersion = cv , lsGlobals = toGlobals m , lsPackages = Map.empty } where toGlobals :: Map GhcPkgId (DumpPackage () () ()) -> Map PackageName (LoadedPackageInfo GhcPkgId) toGlobals m = Map.fromList $ map go $ Map.elems m where identMap = Map.map dpPackageIdent m go :: DumpPackage () () () -> (PackageName, LoadedPackageInfo GhcPkgId) go dp = (name, lpi) where PackageIdentifier name version = dpPackageIdent dp goDep ghcPkgId = case Map.lookup ghcPkgId identMap of Nothing -> Map.empty Just (PackageIdentifier name' _) -> Map.singleton name' (fromVersionRange C.anyVersion) lpi :: LoadedPackageInfo GhcPkgId lpi = LoadedPackageInfo { lpiVersion = version , lpiLocation = dpGhcPkgId dp , lpiFlags = Map.empty , lpiGhcOptions = [] , lpiPackageDeps = Map.unions $ map goDep $ dpDepends dp , lpiExposedModules = Set.fromList $ map (ModuleName . encodeUtf8) $ dpExposedModules dp , lpiHide = not $ dpIsExposed dp } type FindPackageS localLocation = ( Map PackageName (LoadedPackageInfo (SinglePackageLocation, localLocation)) , Map PackageName (Map FlagName Bool) -- flags , Map PackageName Bool -- hide , Map PackageName [Text] -- ghc options ) -- | Find the package at the given 'PackageLocation', grab any flags, -- hidden state, and GHC options from the 'StateT' (removing them from -- the 'StateT'), and add the newly found package to the contained -- 'Map'. findPackage :: forall m localLocation. MonadThrow m => Platform -> CompilerVersion 'CVActual -> (GenericPackageDescription, SinglePackageLocation, localLocation) -> StateT (FindPackageS localLocation) m () findPackage platform compilerVersion (gpd, loc, localLoc) = do (m, allFlags, allHide, allOptions) <- get case Map.lookup name m of Nothing -> return () Just lpi -> throwM $ PackageDefinedTwice name loc (fst (lpiLocation lpi)) let flags = fromMaybe Map.empty $ Map.lookup name allFlags allFlags' = Map.delete name allFlags hide = fromMaybe False $ Map.lookup name allHide allHide' = Map.delete name allHide options = fromMaybe [] $ Map.lookup name allOptions allOptions' = Map.delete name allOptions (name', lpi) = calculate gpd platform compilerVersion (loc, localLoc) flags hide options m' = Map.insert name lpi m assert (name == name') $ put (m', allFlags', allHide', allOptions') where PackageIdentifier name _version = fromCabalPackageIdentifier $ C.package $ C.packageDescription gpd -- | Some hard-coded fixes for build plans, only for hysterical raisins. snapshotDefFixes :: SnapshotDef -> SnapshotDef snapshotDefFixes sd | isOldStackage (sdResolver sd) = sd { sdFlags = Map.unionWith Map.union overrides $ sdFlags sd } where overrides = Map.fromList [ ($(mkPackageName "persistent-sqlite"), Map.singleton $(mkFlagName "systemlib") False) , ($(mkPackageName "yaml"), Map.singleton $(mkFlagName "system-libyaml") False) ] -- Only apply this hack to older Stackage snapshots. In -- particular, nightly-2018-03-13 did not contain these two -- packages. isOldStackage (ResolverStackage (LTS major _)) = major < 11 isOldStackage (ResolverStackage (Nightly (toGregorian -> (year, _, _)))) = year < 2018 isOldStackage _ = False snapshotDefFixes sd = sd -- | Convert a global 'LoadedPackageInfo' to a snapshot one by -- creating a 'PackageLocation'. globalToSnapshot :: PackageName -> LoadedPackageInfo loc -> LoadedPackageInfo (PackageLocationIndex FilePath) globalToSnapshot name lpi = lpi { lpiLocation = PLIndex (PackageIdentifierRevision (PackageIdentifier name (lpiVersion lpi)) CFILatest) } -- | Split the packages into those which have their dependencies met, -- and those that don't. The first argument is packages that are known -- to be available for use as a dependency. The second argument is the -- packages to check. -- -- This works by repeatedly iterating through the list of input -- packages, adding any that have their dependencies satisfied to a map -- (eventually this set is the fst of the result tuple). Once an -- iteration completes without adding anything to this set, it knows it -- has found everything that has its dependencies met, and exits. splitUnmetDeps :: Map PackageName Version -- ^ extra dependencies available -> Map PackageName (LoadedPackageInfo loc) -> ( Map PackageName (LoadedPackageInfo loc) , Map PackageName (LoadedPackageInfo loc) ) splitUnmetDeps extra = start Map.empty . Map.toList where start newGlobals0 toProcess0 | anyAdded = start newGlobals1 toProcess1 | otherwise = (newGlobals1, Map.fromList toProcess1) where (newGlobals1, toProcess1, anyAdded) = loop False newGlobals0 id toProcess0 loop anyAdded newGlobals front [] = (newGlobals, front [], anyAdded) loop anyAdded newGlobals front (x@(k, v):xs) | depsMet newGlobals v = loop True (Map.insert k v newGlobals) front xs | otherwise = loop anyAdded newGlobals (front . (x:)) xs depsMet globals = all (depsMet' globals) . Map.toList . lpiPackageDeps -- MSS 2018-01-10. Previously, we would actually perform a version -- bounds check at this point. I believe this is a mistake: we -- don't want to promote a package from a snapshot to a local just -- because the version ranges aren't satisfied. In fact, we -- intentionally allow snapshots to specify mismatched versions of -- packages, and try building anyway. -- -- With the old behavior: a number of packages would be converted -- and treated as local packages. I specifically stumbled on this -- while investigating Stackage issues #3185, where a revision to -- semigroupoids's tagged dependency caused the builds to -- break. Stack should have just ignored this and printed a -- warning. Instead, Stack believed that semigroupoids was a local -- package, not a snapshot package, and failed. -- -- All that said: I'm pretty certain this is the right behavior, -- but all of this is strongly indicating that we need some code -- cleanup around this promotion business. I don't think I did a -- particularly good job on this code during the extensible -- snapshot rewrite. depsMet' globals (name, _intervals) = case (lpiVersion <$> Map.lookup name globals) <|> Map.lookup name extra of -- The dependency doesn't exist at all in the snapshot or -- extra, therefore this package must be promoted to local as -- well. Nothing -> False -- It exists. As explained above, don't bother checking the -- version bounds, we trust the snapshot. Just _version -> True -- | Calculate a 'LoadedPackageInfo' from the given 'GenericPackageDescription' calculate :: GenericPackageDescription -> Platform -> CompilerVersion 'CVActual -> loc -> Map FlagName Bool -> Bool -- ^ hidden? -> [Text] -- ^ GHC options -> (PackageName, LoadedPackageInfo loc) calculate gpd platform compilerVersion loc flags hide options = (name, lpi) where pconfig = PackageConfig { packageConfigEnableTests = False , packageConfigEnableBenchmarks = False , packageConfigFlags = flags , packageConfigGhcOptions = options , packageConfigCompilerVersion = compilerVersion , packageConfigPlatform = platform } -- We want to ignore test suites and benchmarks, therefore choose -- the package description which modifies buildable pd = pdpModifiedBuildable $ resolvePackageDescription pconfig gpd PackageIdentifier name version = fromCabalPackageIdentifier $ C.package pd lpi = LoadedPackageInfo { lpiVersion = version , lpiLocation = loc , lpiFlags = flags , lpiGhcOptions = options , lpiPackageDeps = Map.map fromVersionRange $ Map.filterWithKey (const . (/= name)) $ packageDependencies pconfig pd , lpiExposedModules = maybe Set.empty (Set.fromList . map fromCabalModuleName . C.exposedModules) (C.library pd) , lpiHide = hide } stack-1.9.3.1/src/Stack/Solver.hs0000644000000000000000000010325313455617610014634 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude #-} {-# LANGUAGE ConstraintKinds #-} {-# LANGUAGE DataKinds #-} {-# LANGUAGE FlexibleContexts #-} {-# LANGUAGE MultiParamTypeClasses #-} {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TemplateHaskell #-} {-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE TupleSections #-} {-# LANGUAGE TypeFamilies #-} module Stack.Solver ( cabalPackagesCheck , findCabalDirs , getResolverConstraints , mergeConstraints , solveExtraDeps , solveResolverSpec , checkSnapBuildPlanActual -- * Internal - for tests , parseCabalOutputLine ) where import Stack.Prelude hiding (Display (..)) import Data.Aeson.Extended (object, (.=), toJSON) import qualified Data.ByteString as S import qualified Data.ByteString.Lazy as BL import Data.Char (isSpace) import Data.Conduit.Process.Typed (eceStderr) import qualified Data.HashMap.Strict as HashMap import qualified Data.HashSet as HashSet import Data.List ( (\\), isSuffixOf , minimumBy, isPrefixOf , intersperse) import Data.List.Extra (groupSortOn) import qualified Data.Map as Map import qualified Data.Set as Set import qualified Data.Text as T import Data.Text.Encoding (decodeUtf8, encodeUtf8) import Data.Tuple (swap) import qualified Data.Yaml as Yaml import qualified Distribution.Package as C import qualified Distribution.PackageDescription as C import qualified Distribution.Text as C import Path import Path.Find (findFiles) import Path.IO hiding (findExecutable, findFiles, withSystemTempDir) import qualified RIO import Stack.Build.Target (gpdVersion) import Stack.BuildPlan import Stack.Config (getLocalPackages, loadConfigYaml) import Stack.Constants (stackDotYaml, wiredInPackages) import Stack.Package (readPackageUnresolvedDir, gpdPackageName) import Stack.PackageIndex import Stack.PrettyPrint import Stack.Setup import Stack.Setup.Installed import Stack.Snapshot (loadSnapshot) import Stack.Types.Build import Stack.Types.BuildPlan import Stack.Types.Compiler import Stack.Types.Config import Stack.Types.FlagName import Stack.Types.PackageIdentifier import Stack.Types.PackageName import Stack.Types.Resolver import Stack.Types.Version import qualified System.Directory as D import qualified System.FilePath as FP import RIO.Process import Text.Regex.Applicative.Text (match, sym, psym, anySym, few) import qualified Data.Text.Normalize as T ( normalize , NormalizationMode(NFC) ) data ConstraintType = Constraint | Preference deriving (Eq) type ConstraintSpec = Map PackageName (Version, Map FlagName Bool) cabalSolver :: HasConfig env => [Path Abs Dir] -- ^ cabal files -> ConstraintType -> ConstraintSpec -- ^ src constraints -> ConstraintSpec -- ^ dep constraints -> [String] -- ^ additional arguments -> RIO env (Either [PackageName] ConstraintSpec) cabalSolver cabalfps constraintType srcConstraints depConstraints cabalArgs = withSystemTempDir "cabal-solver" $ \dir' -> do let versionConstraints = fmap fst depConstraints dir = toFilePath dir' configLines <- getCabalConfig dir constraintType versionConstraints let configFile = dir FP. "cabal.config" liftIO $ S.writeFile configFile $ encodeUtf8 $ T.unlines configLines -- Run from a temporary directory to avoid cabal getting confused by any -- sandbox files, see: -- https://github.com/commercialhaskell/stack/issues/356 -- -- In theory we could use --ignore-sandbox, but not all versions of cabal -- support it. tmpdir <- getTempDir let args = ("--config-file=" ++ configFile) : "install" : "--enable-tests" : "--enable-benchmarks" : "--dry-run" : "--reorder-goals" : "--max-backjumps=-1" : "--package-db=clear" : "--package-db=global" : cabalArgs ++ toConstraintArgs (flagConstraints constraintType) ++ fmap toFilePath cabalfps try ( withWorkingDir (toFilePath tmpdir) $ proc "cabal" args readProcess_ ) >>= either (parseCabalErrors . eceStderr) (parseCabalOutput . BL.toStrict . fst) where errCheck = T.isInfixOf "Could not resolve dependencies" linesNoCR = map stripCR . T.lines cabalBuildErrMsg e = ">>>> Cabal errors begin\n" <> e <> "<<<< Cabal errors end\n" parseCabalErrors err = do let errExit e = error $ "Could not parse cabal-install errors:\n\n" ++ cabalBuildErrMsg (T.unpack e) msg = decodeUtf8With lenientDecode $ toStrictBytes err if errCheck msg then do logInfo "Attempt failed.\n" logInfo $ RIO.display $ cabalBuildErrMsg msg let pkgs = parseConflictingPkgs msg mPkgNames = map (C.simpleParse . T.unpack) pkgs pkgNames = map (fromCabalPackageName . C.pkgName) (catMaybes mPkgNames) when (any isNothing mPkgNames) $ do logInfo $ "*** Only some package names could be parsed: " <> mconcat (intersperse ", " (map displayShow pkgNames)) error $ T.unpack $ "*** User packages involved in cabal failure: " <> T.intercalate ", " (parseConflictingPkgs msg) if pkgNames /= [] then do return $ Left pkgNames else errExit msg else errExit msg parseConflictingPkgs msg = let ls = dropWhile (not . errCheck) $ linesNoCR msg select s = (T.isPrefixOf "trying:" s || T.isPrefixOf "next goal:" s) && T.isSuffixOf "(user goal)" s pkgName = take 1 . T.words . T.drop 1 . T.dropWhile (/= ':') in concatMap pkgName (filter select ls) parseCabalOutput bs = do let ls = drop 1 $ dropWhile (not . T.isPrefixOf "In order, ") $ linesNoCR $ decodeUtf8With lenientDecode bs (errs, pairs) = partitionEithers $ map parseCabalOutputLine ls if null errs then return $ Right (Map.fromList pairs) else error $ "The following lines from cabal-install output could \ \not be parsed: \n" ++ T.unpack (T.intercalate "\n" errs) toConstraintArgs userFlagMap = [formatFlagConstraint package flag enabled | (package, fs) <- Map.toList userFlagMap , (flag, enabled) <- Map.toList fs] formatFlagConstraint package flag enabled = let sign = if enabled then '+' else '-' in "--constraint=" ++ unwords [packageNameString package, sign : flagNameString flag] -- Note the order of the Map union is important -- We override a package in snapshot by a src package flagConstraints Constraint = fmap snd (Map.union srcConstraints depConstraints) -- Even when using preferences we want to -- keep the src package flags unchanged -- TODO - this should be done only for manual flags. flagConstraints Preference = fmap snd srcConstraints -- An ugly parser to extract module id and flags parseCabalOutputLine :: Text -> Either Text (PackageName, (Version, Map FlagName Bool)) parseCabalOutputLine t0 = maybe (Left t0) Right . join . match re $ t0 -- Sample outputs to parse: -- text-1.2.1.1 (latest: 1.2.2.0) -integer-simple (via: parsec-3.1.9) (new package)) -- hspec-snap-1.0.0.0 *test (via: servant-snap-0.5) (new package) -- time-locale-compat-0.1.1.1 -old-locale (via: http-api-data-0.2.2) (new package)) -- flowdock-rest-0.2.0.0 -aeson-compat *test (via: haxl-fxtra-0.0.0.0) (new package) where re = mk <$> some (psym $ not . isSpace) <*> many (lexeme reMaybeFlag) reMaybeFlag = (\s -> Just (True, s)) <$ sym '+' <*> some (psym $ not . isSpace) <|> (\s -> Just (False, s)) <$ sym '-' <*> some (psym $ not . isSpace) <|> Nothing <$ sym '*' <* some (psym $ not . isSpace) <|> Nothing <$ sym '(' <* few anySym <* sym ')' mk :: String -> [Maybe (Bool, String)] -> Maybe (PackageName, (Version, Map FlagName Bool)) mk ident fl = do PackageIdentifier name version <- parsePackageIdentifierFromString ident fl' <- (traverse . traverse) parseFlagNameFromString $ catMaybes fl return (name, (version, Map.fromList $ map swap fl')) lexeme r = some (psym isSpace) *> r getCabalConfig :: HasConfig env => FilePath -- ^ temp dir -> ConstraintType -> Map PackageName Version -- ^ constraints -> RIO env [Text] getCabalConfig dir constraintType constraints = do indices <- view $ cabalLoaderL.to clIndices remotes <- mapM goIndex indices let cache = T.pack $ "remote-repo-cache: " ++ dir return $ cache : remotes ++ map goConstraint (Map.toList constraints) where goIndex index = do src <- configPackageIndex $ indexName index let dstdir = dir FP. T.unpack (indexNameText $ indexName index) -- NOTE: see https://github.com/commercialhaskell/stack/issues/2888 -- for why we are pretending that a 01-index.tar is actually a -- 00-index.tar file. dst0 = dstdir FP. "00-index.tar" dst1 = dstdir FP. "01-index.tar" liftIO $ void $ tryIO $ do D.createDirectoryIfMissing True dstdir D.copyFile (toFilePath src) dst0 D.copyFile (toFilePath src) dst1 return $ T.concat [ "remote-repo: " , indexNameText $ indexName index , ":http://0.0.0.0/fake-url" ] goConstraint (name, version) = assert (not . null . versionString $ version) $ T.concat [ if constraintType == Constraint || name `HashSet.member` wiredInPackages then "constraint: " else "preference: " , T.pack $ packageNameString name , "==" , T.pack $ versionString version ] setupCompiler :: (HasConfig env, HasGHCVariant env) => CompilerVersion 'CVWanted -> RIO env (Maybe ExtraDirs) setupCompiler compiler = do let msg = Just $ T.concat [ "Compiler version (" <> compilerVersionText compiler <> ") " , "required by your resolver specification cannot be found.\n\n" , "Please use '--install-ghc' command line switch to automatically " , "install the compiler or '--system-ghc' to use a suitable " , "compiler available on your PATH." ] config <- view configL (dirs, _, _) <- ensureCompiler SetupOpts { soptsInstallIfMissing = configInstallGHC config , soptsUseSystem = configSystemGHC config , soptsWantedCompiler = compiler , soptsCompilerCheck = configCompilerCheck config , soptsStackYaml = Nothing , soptsForceReinstall = False , soptsSanityCheck = False , soptsSkipGhcCheck = False , soptsSkipMsys = configSkipMsys config , soptsUpgradeCabal = Nothing , soptsResolveMissingGHC = msg , soptsSetupInfoYaml = defaultSetupInfoYaml , soptsGHCBindistURL = Nothing , soptsGHCJSBootOpts = ["--clean"] } return dirs -- | Runs the given inner command with an updated configuration that -- has the desired GHC on the PATH. setupCabalEnv :: (HasConfig env, HasGHCVariant env) => CompilerVersion 'CVWanted -> (CompilerVersion 'CVActual -> RIO env a) -> RIO env a setupCabalEnv compiler inner = do mpaths <- setupCompiler compiler menv0 <- view processContextL envMap <- either throwM (return . removeHaskellEnvVars) $ augmentPathMap (toFilePath <$> maybe [] edBins mpaths) (view envVarsL menv0) menv <- mkProcessContext envMap withProcessContext menv $ do mcabal <- getCabalInstallVersion case mcabal of Nothing -> throwM SolverMissingCabalInstall Just version | version < $(mkVersion "1.24") -> prettyWarn $ "Installed version of cabal-install (" <> display version <> ") doesn't support custom-setup clause, and so may not yield correct results." <> line <> "To resolve this, install a newer version via 'stack install cabal-install'." <> line | version >= $(mkVersion "1.25") -> prettyWarn $ "Installed version of cabal-install (" <> display version <> ") is newer than stack has been tested with. If you run into difficulties, consider downgrading." <> line | otherwise -> return () mver <- getSystemCompiler (whichCompiler compiler) version <- case mver of Just (version, _) -> do logInfo $ "Using compiler: " <> RIO.display version return version Nothing -> error "Failed to determine compiler version. \ \This is most likely a bug." inner version -- | Merge two separate maps, one defining constraints on package versions and -- the other defining package flagmap, into a single map of version and flagmap -- tuples. mergeConstraints :: Map PackageName v -> Map PackageName (Map p f) -> Map PackageName (v, Map p f) mergeConstraints = Map.mergeWithKey -- combine entry in both maps (\_ v f -> Just (v, f)) -- convert entry in first map only (fmap (, Map.empty)) -- convert entry in second map only (\m -> if Map.null m then Map.empty else error "Bug: An entry in flag map must have a corresponding \ \entry in the version map") -- | Given a resolver, user package constraints (versions and flags) and extra -- dependency constraints determine what extra dependencies are required -- outside the resolver snapshot and the specified extra dependencies. -- -- First it tries by using the snapshot and the input extra dependencies -- as hard constraints, if no solution is arrived at by using hard -- constraints it then tries using them as soft constraints or preferences. -- -- It returns either conflicting packages when no solution is arrived at -- or the solution in terms of src package flag settings and extra -- dependencies. solveResolverSpec :: (HasConfig env, HasGHCVariant env) => Path Abs File -- ^ stack.yaml file location -> [Path Abs Dir] -- ^ package dirs containing cabal files -> ( SnapshotDef , ConstraintSpec , ConstraintSpec) -- ^ ( resolver -- , src package constraints -- , extra dependency constraints ) -> RIO env (Either [PackageName] (ConstraintSpec , ConstraintSpec)) -- ^ (Conflicting packages -- (resulting src package specs, external dependency specs)) solveResolverSpec stackYaml cabalDirs (sd, srcConstraints, extraConstraints) = do logInfo $ "Using resolver: " <> RIO.display (sdResolverName sd) let wantedCompilerVersion = sdWantedCompilerVersion sd setupCabalEnv wantedCompilerVersion $ \compilerVersion -> do (compilerVer, snapConstraints) <- getResolverConstraints (Just compilerVersion) stackYaml sd let -- Note - The order in Map.union below is important. -- We want to override snapshot with extra deps depConstraints = Map.union extraConstraints snapConstraints -- Make sure to remove any user packages from the dep constraints -- There are two reasons for this: -- 1. We do not want snapshot versions to override the sources -- 2. Sources may have blank versions leading to bad cabal constraints depOnlyConstraints = Map.difference depConstraints srcConstraints solver t = cabalSolver cabalDirs t srcConstraints depOnlyConstraints $ "-v" : -- TODO make it conditional on debug ["--ghcjs" | whichCompiler compilerVer == Ghcjs] let srcNames = T.intercalate " and " $ ["packages from " <> sdResolverName sd | not (Map.null snapConstraints)] ++ [T.pack (show (Map.size extraConstraints) <> " external packages") | not (Map.null extraConstraints)] logInfo "Asking cabal to calculate a build plan..." unless (Map.null depOnlyConstraints) (logInfo $ "Trying with " <> RIO.display srcNames <> " as hard constraints...") eresult <- solver Constraint eresult' <- case eresult of Left _ | not (Map.null depOnlyConstraints) -> do logInfo $ "Retrying with " <> RIO.display srcNames <> " as preferences..." solver Preference _ -> return eresult case eresult' of Right deps -> do let -- All src package constraints returned by cabal. -- Flags may have changed. srcs = Map.intersection deps srcConstraints inSnap = Map.intersection deps snapConstraints -- All packages which are in the snapshot but cabal solver -- returned versions or flags different from the snapshot. inSnapChanged = Map.differenceWith diffConstraints inSnap snapConstraints -- If a package appears in both the -- snapshot and locally, we don't want to -- include it in extra-deps. This makes -- sure we filter out such packages. See: -- https://github.com/commercialhaskell/stack/issues/3533 `Map.difference` srcConstraints -- Packages neither in snapshot, nor srcs extra = Map.difference deps (Map.union srcConstraints snapConstraints) external = Map.union inSnapChanged extra -- Just in case. -- If cabal output contains versions of user packages, those -- versions better be the same as those in our cabal file i.e. -- cabal should not be solving using versions from external -- indices. let outVers = fmap fst srcs inVers = fmap fst srcConstraints bothVers = Map.intersectionWith (\v1 v2 -> (v1, v2)) inVers outVers unless (outVers `Map.isSubmapOf` inVers) $ do let msg = "Error: user package versions returned by cabal \ \solver are not the same as the versions in the \ \cabal files:\n" -- TODO We can do better in formatting the message error $ T.unpack $ msg <> showItems (map show (Map.toList bothVers)) logInfo $ "Successfully determined a build plan with " <> displayShow (Map.size external) <> " external dependencies." return $ Right (srcs, external) Left x -> do logInfo "*** Failed to arrive at a workable build plan." return $ Left x where -- Think of the first map as the deps reported in cabal output and -- the second as the snapshot packages -- Note: For flags we only require that the flags in cabal output be a -- subset of the snapshot flags. This is to avoid a false difference -- reporting due to any spurious flags in the build plan which will -- always be absent in the cabal output. diffConstraints :: (Eq v, Eq a, Ord k) => (v, Map k a) -> (v, Map k a) -> Maybe (v, Map k a) diffConstraints (v, f) (v', f') | (v == v') && (f `Map.isSubmapOf` f') = Nothing | otherwise = Just (v, f) -- | Given a resolver (snpashot, compiler or custom resolver) -- return the compiler version, package versions and packages flags -- for that resolver. getResolverConstraints :: (HasConfig env, HasGHCVariant env) => Maybe (CompilerVersion 'CVActual) -- ^ actually installed compiler -> Path Abs File -> SnapshotDef -> RIO env (CompilerVersion 'CVActual, Map PackageName (Version, Map FlagName Bool)) getResolverConstraints mcompilerVersion stackYaml sd = do ls <- loadSnapshot mcompilerVersion (parent stackYaml) sd return (lsCompilerVersion ls, lsConstraints ls) where lpiConstraints lpi = (lpiVersion lpi, lpiFlags lpi) lsConstraints ls = Map.union (Map.map lpiConstraints (lsPackages ls)) (Map.map lpiConstraints (lsGlobals ls)) -- | Finds all directories with a .cabal file or an hpack -- package.yaml. Subdirectories can be included depending on the -- @recurse@ parameter. findCabalDirs :: HasConfig env => Bool -> Path Abs Dir -> RIO env (Set (Path Abs Dir)) findCabalDirs recurse dir = Set.fromList . map parent <$> liftIO (findFiles dir isHpackOrCabal subdirFilter) where subdirFilter subdir = recurse && not (isIgnored subdir) isHpack = (== "package.yaml") . toFilePath . filename isCabal = (".cabal" `isSuffixOf`) . toFilePath isHpackOrCabal x = isHpack x || isCabal x isIgnored path = "." `isPrefixOf` dirName || dirName `Set.member` ignoredDirs where dirName = FP.dropTrailingPathSeparator (toFilePath (dirname path)) -- | Special directories that we don't want to traverse for .cabal files ignoredDirs :: Set FilePath ignoredDirs = Set.fromList [ "dist" ] -- | Perform some basic checks on a list of cabal files to be used for creating -- stack config. It checks for duplicate package names, package name and -- cabal file name mismatch and reports any issues related to those. -- -- If no error occurs it returns filepath and @GenericPackageDescription@s -- pairs as well as any filenames for duplicate packages not included in the -- pairs. cabalPackagesCheck :: (HasConfig env, HasGHCVariant env) => [Path Abs Dir] -> String -> Maybe String -> RIO env ( Map PackageName (Path Abs File, C.GenericPackageDescription) , [Path Abs File]) cabalPackagesCheck cabaldirs noPkgMsg dupErrMsg = do when (null cabaldirs) $ error noPkgMsg relpaths <- mapM prettyPath cabaldirs logInfo "Using cabal packages:" logInfo $ formatGroup relpaths packages <- map (\(x, y) -> (y, x)) <$> mapM (flip readPackageUnresolvedDir True) cabaldirs -- package name cannot be empty or missing otherwise -- it will result in cabal solver failure. -- stack requires packages name to match the cabal file name -- Just the latter check is enough to cover both the cases let normalizeString = T.unpack . T.normalize T.NFC . T.pack getNameMismatchPkg (fp, gpd) | (normalizeString . show . gpdPackageName) gpd /= (normalizeString . FP.takeBaseName . toFilePath) fp = Just fp | otherwise = Nothing nameMismatchPkgs = mapMaybe getNameMismatchPkg packages when (nameMismatchPkgs /= []) $ do rels <- mapM prettyPath nameMismatchPkgs error $ "Package name as defined in the .cabal file must match the \ \.cabal file name.\n\ \Please fix the following packages and try again:\n" <> T.unpack (utf8BuilderToText (formatGroup rels)) let dupGroups = filter ((> 1) . length) . groupSortOn (gpdPackageName . snd) dupAll = concat $ dupGroups packages -- Among duplicates prefer to include the ones in upper level dirs pathlen = length . FP.splitPath . toFilePath . fst getmin = minimumBy (compare `on` pathlen) dupSelected = map getmin (dupGroups packages) dupIgnored = dupAll \\ dupSelected unique = packages \\ dupIgnored when (dupIgnored /= []) $ do dups <- mapM (mapM (prettyPath. fst)) (dupGroups packages) logWarn $ "Following packages have duplicate package names:\n" <> mconcat (intersperse "\n" (map formatGroup dups)) case dupErrMsg of Nothing -> logWarn $ "Packages with duplicate names will be ignored.\n" <> "Packages in upper level directories will be preferred.\n" Just msg -> error msg return (Map.fromList $ map (\(file, gpd) -> (gpdPackageName gpd,(file, gpd))) unique , map fst dupIgnored) formatGroup :: [String] -> Utf8Builder formatGroup = foldMap (\path -> "- " <> fromString path <> "\n") reportMissingCabalFiles :: HasConfig env => [Path Abs File] -- ^ Directories to scan -> Bool -- ^ Whether to scan sub-directories -> RIO env () reportMissingCabalFiles cabalfps includeSubdirs = do allCabalDirs <- findCabalDirs includeSubdirs =<< getCurrentDir relpaths <- mapM prettyPath $ Set.toList $ allCabalDirs `Set.difference` Set.fromList (map parent cabalfps) unless (null relpaths) $ do logWarn "The following packages are missing from the config:" logWarn $ formatGroup relpaths -- TODO Currently solver uses a stack.yaml in the parent chain when there is -- no stack.yaml in the current directory. It should instead look for a -- stack yaml only in the current directory and suggest init if there is -- none available. That will make the behavior consistent with init and provide -- a correct meaning to a --ignore-subdirs option if implemented. -- | Verify the combination of resolver, package flags and extra -- dependencies in an existing stack.yaml and suggest changes in flags or -- extra dependencies so that the specified packages can be compiled. solveExtraDeps :: HasEnvConfig env => Bool -- ^ modify stack.yaml? -> RIO env () solveExtraDeps modStackYaml = do bconfig <- view buildConfigL let stackYaml = bcStackYaml bconfig relStackYaml <- prettyPath stackYaml logInfo $ "Using configuration file: " <> fromString relStackYaml lp <- getLocalPackages let packages = lpProject lp let noPkgMsg = "No cabal packages found in " <> relStackYaml <> ". Please add at least one directory containing a .cabal \ \file. You can also use 'stack init' to automatically \ \generate the config file." dupPkgFooter = "Please remove the directories containing duplicate \ \entries from '" <> relStackYaml <> "'." cabalDirs = map lpvRoot $ Map.elems packages cabalfps = map lpvCabalFP $ Map.elems packages -- TODO when solver supports --ignore-subdirs option pass that as the -- second argument here. reportMissingCabalFiles cabalfps True (bundle, _) <- cabalPackagesCheck cabalDirs noPkgMsg (Just dupPkgFooter) let gpds = Map.elems $ fmap snd bundle oldFlags = bcFlags bconfig oldExtraVersions = Map.map (gpdVersion . fst) (lpDependencies lp) sd = bcSnapshotDef bconfig resolver = sdResolver sd oldSrcs = gpdPackages gpds oldSrcFlags = Map.intersection oldFlags oldSrcs oldExtraFlags = Map.intersection oldFlags oldExtraVersions srcConstraints = mergeConstraints oldSrcs oldSrcFlags extraConstraints = mergeConstraints oldExtraVersions oldExtraFlags resolverResult <- checkSnapBuildPlanActual (parent stackYaml) gpds (Just oldSrcFlags) sd resultSpecs <- case resolverResult of BuildPlanCheckOk flags -> return $ Just (mergeConstraints oldSrcs flags, Map.empty) BuildPlanCheckPartial {} -> either (const Nothing) Just <$> solveResolverSpec stackYaml cabalDirs (sd, srcConstraints, extraConstraints) -- TODO Solver should also use the init code to ignore incompatible -- packages BuildPlanCheckFail {} -> throwM $ ResolverMismatch IsSolverCmd (sdResolverName sd) (show resolverResult) (srcs, edeps) <- case resultSpecs of Nothing -> throwM (SolverGiveUp giveUpMsg) Just x -> return x mOldResolver <- view $ configL.to (fmap (projectResolver . fst) . configMaybeProject) let flags = removeSrcPkgDefaultFlags gpds (fmap snd (Map.union srcs edeps)) versions = fmap fst edeps vDiff v v' = if v == v' then Nothing else Just v versionsDiff = Map.differenceWith vDiff newVersions = versionsDiff versions oldExtraVersions goneVersions = versionsDiff oldExtraVersions versions fDiff f f' = if f == f' then Nothing else Just f flagsDiff = Map.differenceWith fDiff newFlags = flagsDiff flags oldFlags goneFlags = flagsDiff oldFlags flags changed = any (not . Map.null) [newVersions, goneVersions] || any (not . Map.null) [newFlags, goneFlags] || any (/= void resolver) (fmap void mOldResolver) if changed then do logInfo "" logInfo $ "The following changes will be made to " <> fromString relStackYaml <> ":" printResolver (fmap void mOldResolver) (void resolver) printFlags newFlags "* Flags to be added" printDeps newVersions "* Dependencies to be added" printFlags goneFlags "* Flags to be deleted" printDeps goneVersions "* Dependencies to be deleted" -- TODO backup the old config file if modStackYaml then do writeStackYaml stackYaml resolver versions flags logInfo $ "Updated " <> fromString relStackYaml else do logInfo $ "To automatically update " <> fromString relStackYaml <> ", rerun with '--update-config'" else logInfo $ "No changes needed to " <> fromString relStackYaml where indentLines t = T.unlines $ fmap (" " <>) (T.lines t) printResolver mOldRes res = do forM_ mOldRes $ \oldRes -> when (res /= oldRes) $ do logInfo $ "* Resolver changes from " <> RIO.display (resolverRawName oldRes) <> " to " <> RIO.display (resolverRawName res) printFlags fl msg = do unless (Map.null fl) $ do logInfo $ fromString msg logInfo $ RIO.display $ indentLines $ decodeUtf8 $ Yaml.encode $ object ["flags" .= fl] printDeps deps msg = do unless (Map.null deps) $ do logInfo $ fromString msg logInfo $ RIO.display $ indentLines $ decodeUtf8 $ Yaml.encode $ object ["extra-deps" .= map fromTuple (Map.toList deps)] writeStackYaml path res deps fl = do let fp = toFilePath path obj <- liftIO (Yaml.decodeFileEither fp) >>= either throwM return -- Check input file and show warnings _ <- loadConfigYaml (parseProjectAndConfigMonoid (parent path)) path let obj' = HashMap.insert "extra-deps" (toJSON $ map fromTuple $ Map.toList deps) $ HashMap.insert ("flags" :: Text) (toJSON fl) $ HashMap.insert ("resolver" :: Text) (toJSON res) obj liftIO $ Yaml.encodeFile fp obj' giveUpMsg = concat [ " - Update external packages with 'stack update' and try again.\n" , " - Tweak " <> toFilePath stackDotYaml <> " and try again\n" , " - Remove any unnecessary packages.\n" , " - Add any missing remote packages.\n" , " - Add extra dependencies to guide solver.\n" , " - Adjust resolver.\n" ] -- | Same as 'checkSnapBuildPLan', but set up a real GHC if needed. -- -- If we're using a Stackage snapshot, we can use the snapshot hints -- to determine global library information. This will not be available -- for custom and GHC resolvers, however. Therefore, we insist that it -- be installed first. Fortunately, the standard `stack solver` -- behavior only chooses Stackage snapshots, so the common case will -- not force the installation of a bunch of GHC versions. checkSnapBuildPlanActual :: (HasConfig env, HasGHCVariant env) => Path Abs Dir -- ^ project root, used for checking out necessary files -> [C.GenericPackageDescription] -> Maybe (Map PackageName (Map FlagName Bool)) -> SnapshotDef -> RIO env BuildPlanCheck checkSnapBuildPlanActual root gpds flags sd = do let forNonSnapshot inner = setupCabalEnv (sdWantedCompilerVersion sd) (inner . Just) runner = case sdResolver sd of ResolverStackage _ -> ($ Nothing) ResolverCompiler _ -> forNonSnapshot ResolverCustom _ _ -> forNonSnapshot runner $ checkSnapBuildPlan root gpds flags sd prettyPath :: forall r t m. (MonadIO m, RelPath (Path r t) ~ Path Rel t, AnyPath (Path r t)) => Path r t -> m String prettyPath path = do eres <- liftIO $ try $ makeRelativeToCurrentDir path return $ case eres of Left (_ :: PathException) -> toFilePath path Right res -> toFilePath (res :: Path Rel t) stack-1.9.3.1/src/Stack/StaticBytes.hs0000644000000000000000000001671313455617610015624 0ustar0000000000000000-- This module can (and perhaps should) be separate into its own -- package, it's generally useful. {-# LANGUAGE DeriveDataTypeable #-} {-# LANGUAGE DeriveGeneric #-} {-# LANGUAGE DeriveAnyClass #-} {-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE GADTs #-} {-# LANGUAGE NoImplicitPrelude #-} module Stack.StaticBytes ( Bytes8 , Bytes16 , Bytes32 , Bytes64 , Bytes128 , DynamicBytes , StaticBytes , StaticBytesException (..) , toStaticExact , toStaticPad , toStaticTruncate , toStaticPadTruncate , fromStatic ) where import Stack.Prelude hiding (words) import qualified Data.ByteString as B import qualified Data.ByteString.Internal as B import qualified Data.Vector.Primitive as VP import qualified Data.Vector.Unboxed as VU import qualified Data.Vector.Unboxed.Base as VU import qualified Data.Vector.Storable as VS import System.IO.Unsafe (unsafePerformIO) import Foreign.Ptr import Foreign.ForeignPtr import Foreign.Storable import Data.Bits import qualified Data.Primitive.ByteArray as BA import Data.ByteArray newtype Bytes8 = Bytes8 Word64 deriving (Eq, Ord, Generic, NFData, Hashable, Data, Store) instance Show Bytes8 where -- FIXME good enough? show (Bytes8 w) = show (fromWordsD 8 [w] :: B.ByteString) data Bytes16 = Bytes16 !Bytes8 !Bytes8 deriving (Show, Eq, Ord, Generic, NFData, Hashable, Data, Store) data Bytes32 = Bytes32 !Bytes16 !Bytes16 deriving (Show, Eq, Ord, Generic, NFData, Hashable, Data, Store) data Bytes64 = Bytes64 !Bytes32 !Bytes32 deriving (Show, Eq, Ord, Generic, NFData, Hashable, Data, Store) data Bytes128 = Bytes128 !Bytes64 !Bytes64 deriving (Show, Eq, Ord, Generic, NFData, Hashable, Data, Store) data StaticBytesException = NotEnoughBytes | TooManyBytes deriving (Show, Eq, Typeable) instance Exception StaticBytesException -- All lengths below are given in bytes class DynamicBytes dbytes where lengthD :: dbytes -> Int -- | Yeah, it looks terrible to use a list here, but fusion should -- kick in withPeekD :: dbytes -> ((Int -> IO Word64) -> IO a) -> IO a -- | May throw a runtime exception if invariants are violated! fromWordsD :: Int -> [Word64] -> dbytes fromWordsForeign :: (ForeignPtr a -> Int -> b) -> Int -> [Word64] -> b fromWordsForeign wrapper len words0 = unsafePerformIO $ do fptr <- B.mallocByteString len withForeignPtr fptr $ \ptr -> do let loop _ [] = return () loop off (w:ws) = do pokeElemOff (castPtr ptr) off w loop (off + 1) ws loop 0 words0 return $ wrapper fptr len withPeekForeign :: (ForeignPtr a, Int, Int) -> ((Int -> IO Word64) -> IO b) -> IO b withPeekForeign (fptr, off, len) inner = withForeignPtr fptr $ \ptr -> do let f off' | off' >= len = return 0 | off' + 8 > len = do let loop w64 i | off' + i >= len = return w64 | otherwise = do w8 :: Word8 <- peekByteOff ptr (off + off' + i) let w64' = shiftL (fromIntegral w8) (i * 8) .|. w64 loop w64' (i + 1) loop 0 0 | otherwise = peekByteOff ptr (off + off') inner f instance DynamicBytes B.ByteString where lengthD = B.length fromWordsD = fromWordsForeign (\fptr len -> B.fromForeignPtr fptr 0 len) withPeekD = withPeekForeign . B.toForeignPtr instance word8 ~ Word8 => DynamicBytes (VS.Vector word8) where lengthD = VS.length fromWordsD = fromWordsForeign VS.unsafeFromForeignPtr0 withPeekD = withPeekForeign . VS.unsafeToForeignPtr instance word8 ~ Word8 => DynamicBytes (VP.Vector word8) where lengthD = VP.length fromWordsD len words0 = unsafePerformIO $ do ba <- BA.newByteArray len let loop _ [] = VP.Vector 0 len <$> BA.unsafeFreezeByteArray ba loop i (w:ws) = do BA.writeByteArray ba i w loop (i + 1) ws loop 0 words0 withPeekD (VP.Vector off len ba) inner = do let f off' | off' >= len = return 0 | off' + 8 > len = do let loop w64 i | off' + i >= len = return w64 | otherwise = do let w8 :: Word8 = BA.indexByteArray ba (off + off' + i) let w64' = shiftL (fromIntegral w8) (i * 8) .|. w64 loop w64' (i + 1) loop 0 0 | otherwise = return $ BA.indexByteArray ba (off + (off' `div` 8)) inner f instance word8 ~ Word8 => DynamicBytes (VU.Vector word8) where lengthD = VU.length fromWordsD len words = VU.V_Word8 (fromWordsD len words) withPeekD (VU.V_Word8 v) = withPeekD v class StaticBytes sbytes where lengthS :: proxy sbytes -> Int -- use type level literals instead? -- difference list toWordsS :: sbytes -> [Word64] -> [Word64] usePeekS :: Int -> (Int -> IO Word64) -> IO sbytes instance StaticBytes Bytes8 where lengthS _ = 8 toWordsS (Bytes8 w) = (w:) usePeekS off f = Bytes8 <$> f off instance StaticBytes Bytes16 where lengthS _ = 16 toWordsS (Bytes16 b1 b2) = toWordsS b1 . toWordsS b2 usePeekS off f = Bytes16 <$> usePeekS off f <*> usePeekS (off + 8) f instance StaticBytes Bytes32 where lengthS _ = 32 toWordsS (Bytes32 b1 b2) = toWordsS b1 . toWordsS b2 usePeekS off f = Bytes32 <$> usePeekS off f <*> usePeekS (off + 16) f instance StaticBytes Bytes64 where lengthS _ = 64 toWordsS (Bytes64 b1 b2) = toWordsS b1 . toWordsS b2 usePeekS off f = Bytes64 <$> usePeekS off f <*> usePeekS (off + 32) f instance StaticBytes Bytes128 where lengthS _ = 128 toWordsS (Bytes128 b1 b2) = toWordsS b1 . toWordsS b2 usePeekS off f = Bytes128 <$> usePeekS off f <*> usePeekS (off + 64) f instance ByteArrayAccess Bytes8 where length _ = 8 withByteArray = withByteArrayS instance ByteArrayAccess Bytes16 where length _ = 16 withByteArray = withByteArrayS instance ByteArrayAccess Bytes32 where length _ = 32 withByteArray = withByteArrayS instance ByteArrayAccess Bytes64 where length _ = 64 withByteArray = withByteArrayS instance ByteArrayAccess Bytes128 where length _ = 128 withByteArray = withByteArrayS withByteArrayS :: StaticBytes sbytes => sbytes -> (Ptr p -> IO a) -> IO a withByteArrayS sbytes = withByteArray (fromStatic sbytes :: ByteString) toStaticExact :: forall dbytes sbytes. (DynamicBytes dbytes, StaticBytes sbytes) => dbytes -> Either StaticBytesException sbytes toStaticExact dbytes = case compare (lengthD dbytes) (lengthS (Nothing :: Maybe sbytes)) of LT -> Left NotEnoughBytes GT -> Left TooManyBytes EQ -> Right (toStaticPadTruncate dbytes) toStaticPad :: forall dbytes sbytes. (DynamicBytes dbytes, StaticBytes sbytes) => dbytes -> Either StaticBytesException sbytes toStaticPad dbytes = case compare (lengthD dbytes) (lengthS (Nothing :: Maybe sbytes)) of GT -> Left TooManyBytes _ -> Right (toStaticPadTruncate dbytes) toStaticTruncate :: forall dbytes sbytes. (DynamicBytes dbytes, StaticBytes sbytes) => dbytes -> Either StaticBytesException sbytes toStaticTruncate dbytes = case compare (lengthD dbytes) (lengthS (Nothing :: Maybe sbytes)) of LT -> Left NotEnoughBytes _ -> Right (toStaticPadTruncate dbytes) toStaticPadTruncate :: (DynamicBytes dbytes, StaticBytes sbytes) => dbytes -> sbytes toStaticPadTruncate dbytes = unsafePerformIO (withPeekD dbytes (usePeekS 0)) fromStatic :: forall dbytes sbytes. (DynamicBytes dbytes, StaticBytes sbytes) => sbytes -> dbytes fromStatic = fromWordsD (lengthS (Nothing :: Maybe sbytes)) . ($ []) . toWordsS stack-1.9.3.1/src/Stack/Types/Build.hs0000644000000000000000000006715113455617610015533 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude #-} {-# LANGUAGE CPP #-} {-# LANGUAGE DataKinds #-} {-# LANGUAGE DeriveDataTypeable #-} {-# LANGUAGE DeriveGeneric #-} {-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE GeneralizedNewtypeDeriving #-} {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TemplateHaskell #-} -- | Build-specific types. module Stack.Types.Build (StackBuildException(..) ,FlagSource(..) ,UnusedFlags(..) ,InstallLocation(..) ,ModTime ,modTime ,Installed(..) ,piiVersion ,piiLocation ,Task(..) ,taskIsTarget ,taskLocation ,LocalPackage(..) ,BaseConfigOpts(..) ,Plan(..) ,TestOpts(..) ,BenchmarkOpts(..) ,FileWatchOpts(..) ,BuildOpts(..) ,BuildSubset(..) ,defaultBuildOpts ,TaskType(..) ,ttPackageLocation ,TaskConfigOpts(..) ,BuildCache(..) ,buildCacheVC ,ConfigCache(..) ,configCacheVC ,configureOpts ,CachePkgSrc (..) ,toCachePkgSrc ,isStackOpt ,wantedLocalPackages ,FileCacheInfo (..) ,ConfigureOpts (..) ,PrecompiledCache (..) ,precompiledCacheVC) where import Stack.Prelude import qualified Data.ByteString as S import Data.Char (isSpace) import Data.List.Extra import qualified Data.Map as Map import qualified Data.Set as Set import Data.Store.Version import Data.Store.VersionTagged import qualified Data.Text as T import Data.Text.Encoding (decodeUtf8With) import Data.Text.Encoding.Error (lenientDecode) import Data.Time.Calendar import Data.Time.Clock import Distribution.PackageDescription (TestSuiteInterface) import Distribution.System (Arch) import qualified Distribution.Text as C import Path (mkRelDir, parseRelDir, ()) import Path.Extra (toFilePathNoTrailingSep) import Stack.Constants import Stack.Types.BuildPlan import Stack.Types.Compiler import Stack.Types.CompilerBuild import Stack.Types.Config import Stack.Types.FlagName import Stack.Types.GhcPkgId import Stack.Types.NamedComponent import Stack.Types.Package import Stack.Types.PackageIdentifier import Stack.Types.PackageName import Stack.Types.Version import System.Exit (ExitCode (ExitFailure)) import System.FilePath (pathSeparator) import RIO.Process (showProcessArgDebug) ---------------------------------------------- -- Exceptions data StackBuildException = Couldn'tFindPkgId PackageName | CompilerVersionMismatch (Maybe (CompilerVersion 'CVActual, Arch)) -- found (CompilerVersion 'CVWanted, Arch) -- expected GHCVariant -- expected CompilerBuild -- expected VersionCheck (Maybe (Path Abs File)) -- Path to the stack.yaml file Text -- recommended resolution | Couldn'tParseTargets [Text] | UnknownTargets (Set PackageName) -- no known version (Map PackageName Version) -- not in snapshot, here's the most recent version in the index (Path Abs File) -- stack.yaml | TestSuiteFailure PackageIdentifier (Map Text (Maybe ExitCode)) (Maybe (Path Abs File)) S.ByteString | TestSuiteTypeUnsupported TestSuiteInterface | ConstructPlanFailed String | CabalExitedUnsuccessfully ExitCode PackageIdentifier (Path Abs File) -- cabal Executable [String] -- cabal arguments (Maybe (Path Abs File)) -- logfiles location [Text] -- log contents | SetupHsBuildFailure ExitCode (Maybe PackageIdentifier) -- which package's custom setup, is simple setup if Nothing (Path Abs File) -- ghc Executable [String] -- ghc arguments (Maybe (Path Abs File)) -- logfiles location [Text] -- log contents | ExecutionFailure [SomeException] | LocalPackageDoesn'tMatchTarget PackageName Version -- local version Version -- version specified on command line | NoSetupHsFound (Path Abs Dir) | InvalidFlagSpecification (Set UnusedFlags) | TargetParseException [Text] | SolverGiveUp String | SolverMissingCabalInstall | SomeTargetsNotBuildable [(PackageName, NamedComponent)] | TestSuiteExeMissing Bool String String String | CabalCopyFailed Bool String | LocalPackagesPresent [PackageIdentifier] deriving Typeable data FlagSource = FSCommandLine | FSStackYaml deriving (Show, Eq, Ord) data UnusedFlags = UFNoPackage FlagSource PackageName | UFFlagsNotDefined FlagSource Package (Set FlagName) | UFSnapshot PackageName deriving (Show, Eq, Ord) instance Show StackBuildException where show (Couldn'tFindPkgId name) = "After installing " <> packageNameString name <> ", the package id couldn't be found " <> "(via ghc-pkg describe " <> packageNameString name <> "). This shouldn't happen, " <> "please report as a bug" show (CompilerVersionMismatch mactual (expected, earch) ghcVariant ghcBuild check mstack resolution) = concat [ case mactual of Nothing -> "No compiler found, expected " Just (actual, arch) -> concat [ "Compiler version mismatched, found " , compilerVersionString actual , " (" , C.display arch , ")" , ", but expected " ] , case check of MatchMinor -> "minor version match with " MatchExact -> "exact version " NewerMinor -> "minor version match or newer with " , compilerVersionString expected , " (" , C.display earch , ghcVariantSuffix ghcVariant , compilerBuildSuffix ghcBuild , ") (based on " , case mstack of Nothing -> "command line arguments" Just stack -> "resolver setting in " ++ toFilePath stack , ").\n" , T.unpack resolution ] show (Couldn'tParseTargets targets) = unlines $ "The following targets could not be parsed as package names or directories:" : map T.unpack targets show (UnknownTargets noKnown notInSnapshot stackYaml) = unlines $ noKnown' ++ notInSnapshot' where noKnown' | Set.null noKnown = [] | otherwise = return $ "The following target packages were not found: " ++ intercalate ", " (map packageNameString $ Set.toList noKnown) ++ "\nSee https://docs.haskellstack.org/en/v" <> versionString stackMinorVersion <> "/build_command/#target-syntax for details." notInSnapshot' | Map.null notInSnapshot = [] | otherwise = "The following packages are not in your snapshot, but exist" : "in your package index. Recommended action: add them to your" : ("extra-deps in " ++ toFilePath stackYaml) : "(Note: these are the most recent versions," : "but there's no guarantee that they'll build together)." : "" : map (\(name, version') -> "- " ++ packageIdentifierString (PackageIdentifier name version')) (Map.toList notInSnapshot) show (TestSuiteFailure ident codes mlogFile bs) = unlines $ concat [ ["Test suite failure for package " ++ packageIdentifierString ident] , flip map (Map.toList codes) $ \(name, mcode) -> concat [ " " , T.unpack name , ": " , case mcode of Nothing -> " executable not found" Just ec -> " exited with: " ++ show ec ] , return $ case mlogFile of Nothing -> "Logs printed to console" -- TODO Should we load up the full error output and print it here? Just logFile -> "Full log available at " ++ toFilePath logFile , if S.null bs then [] else ["", "", doubleIndent $ T.unpack $ decodeUtf8With lenientDecode bs] ] where indent = dropWhileEnd isSpace . unlines . fmap (\line -> " " ++ line) . lines doubleIndent = indent . indent show (TestSuiteTypeUnsupported interface) = "Unsupported test suite type: " <> show interface -- Supressing duplicate output show (CabalExitedUnsuccessfully exitCode taskProvides' execName fullArgs logFiles bss) = showBuildError False exitCode (Just taskProvides') execName fullArgs logFiles bss show (SetupHsBuildFailure exitCode mtaskProvides execName fullArgs logFiles bss) = showBuildError True exitCode mtaskProvides execName fullArgs logFiles bss show (ExecutionFailure es) = intercalate "\n\n" $ map show es show (LocalPackageDoesn'tMatchTarget name localV requestedV) = concat [ "Version for local package " , packageNameString name , " is " , versionString localV , ", but you asked for " , versionString requestedV , " on the command line" ] show (NoSetupHsFound dir) = "No Setup.hs or Setup.lhs file found in " ++ toFilePath dir show (InvalidFlagSpecification unused) = unlines $ "Invalid flag specification:" : map go (Set.toList unused) where showFlagSrc :: FlagSource -> String showFlagSrc FSCommandLine = " (specified on command line)" showFlagSrc FSStackYaml = " (specified in stack.yaml)" go :: UnusedFlags -> String go (UFNoPackage src name) = concat [ "- Package '" , packageNameString name , "' not found" , showFlagSrc src ] go (UFFlagsNotDefined src pkg flags) = concat [ "- Package '" , name , "' does not define the following flags" , showFlagSrc src , ":\n" , intercalate "\n" (map (\flag -> " " ++ flagNameString flag) (Set.toList flags)) , "\n- Flags defined by package '" ++ name ++ "':\n" , intercalate "\n" (map (\flag -> " " ++ name ++ ":" ++ flagNameString flag) (Set.toList pkgFlags)) ] where name = packageNameString (packageName pkg) pkgFlags = packageDefinedFlags pkg go (UFSnapshot name) = concat [ "- Attempted to set flag on snapshot package " , packageNameString name , ", please add to extra-deps" ] show (TargetParseException [err]) = "Error parsing targets: " ++ T.unpack err show (TargetParseException errs) = unlines $ "The following errors occurred while parsing the build targets:" : map (("- " ++) . T.unpack) errs show (SolverGiveUp msg) = concat [ "\nSolver could not resolve package dependencies.\n" , "You can try the following:\n" , msg ] show SolverMissingCabalInstall = unlines [ "Solver requires that cabal be on your PATH" , "Try running 'stack install cabal-install'" ] show (SomeTargetsNotBuildable xs) = "The following components have 'buildable: False' set in the cabal configuration, and so cannot be targets:\n " ++ T.unpack (renderPkgComponents xs) ++ "\nTo resolve this, either provide flags such that these components are buildable, or only specify buildable targets." show (TestSuiteExeMissing isSimpleBuildType exeName pkgName testName) = missingExeError isSimpleBuildType $ concat [ "Test suite executable \"" , exeName , " not found for " , pkgName , ":test:" , testName ] show (CabalCopyFailed isSimpleBuildType innerMsg) = missingExeError isSimpleBuildType $ concat [ "'cabal copy' failed. Error message:\n" , innerMsg , "\n" ] show (ConstructPlanFailed msg) = msg show (LocalPackagesPresent locals) = unlines $ "Local packages are not allowed when using the script command. Packages found:" : map (\ident -> "- " ++ packageIdentifierString ident) locals missingExeError :: Bool -> String -> String missingExeError isSimpleBuildType msg = unlines $ msg : case possibleCauses of [] -> [] [cause] -> ["One possible cause of this issue is:\n* " <> cause] _ -> "Possible causes of this issue:" : map ("* " <>) possibleCauses where possibleCauses = "No module named \"Main\". The 'main-is' source file should usually have a header indicating that it's a 'Main' module." : "A cabal file that refers to nonexistent other files (e.g. a license-file that doesn't exist). Running 'cabal check' may point out these issues." : if isSimpleBuildType then [] else ["The Setup.hs file is changing the installation target dir."] showBuildError :: Bool -> ExitCode -> Maybe PackageIdentifier -> Path Abs File -> [String] -> Maybe (Path Abs File) -> [Text] -> String showBuildError isBuildingSetup exitCode mtaskProvides execName fullArgs logFiles bss = let fullCmd = unwords $ dropQuotes (toFilePath execName) : map (T.unpack . showProcessArgDebug) fullArgs logLocations = maybe "" (\fp -> "\n Logs have been written to: " ++ toFilePath fp) logFiles in "\n-- While building " ++ (case (isBuildingSetup, mtaskProvides) of (False, Nothing) -> error "Invariant violated: unexpected case in showBuildError" (False, Just taskProvides') -> "package " ++ dropQuotes (show taskProvides') (True, Nothing) -> "simple Setup.hs" (True, Just taskProvides') -> "custom Setup.hs for package " ++ dropQuotes (show taskProvides') ) ++ " using:\n " ++ fullCmd ++ "\n" ++ " Process exited with code: " ++ show exitCode ++ (if exitCode == ExitFailure (-9) then " (THIS MAY INDICATE OUT OF MEMORY)" else "") ++ logLocations ++ (if null bss then "" else "\n\n" ++ doubleIndent (map T.unpack bss)) where doubleIndent = dropWhileEnd isSpace . unlines . fmap (\line -> " " ++ line) dropQuotes = filter ('\"' /=) instance Exception StackBuildException ---------------------------------------------- -- | Package dependency oracle. newtype PkgDepsOracle = PkgDeps PackageName deriving (Show,Typeable,Eq,Hashable,Store,NFData) -- | Stored on disk to know whether the files have changed. newtype BuildCache = BuildCache { buildCacheTimes :: Map FilePath FileCacheInfo -- ^ Modification times of files. } deriving (Generic, Eq, Show, Data, Typeable) instance NFData BuildCache instance Store BuildCache buildCacheVC :: VersionConfig BuildCache buildCacheVC = storeVersionConfig "build-v1" "KVUoviSWWAd7tiRRGeWAvd0UIN4=" -- | Stored on disk to know whether the flags have changed. data ConfigCache = ConfigCache { configCacheOpts :: !ConfigureOpts -- ^ All options used for this package. , configCacheDeps :: !(Set GhcPkgId) -- ^ The GhcPkgIds of all of the dependencies. Since Cabal doesn't take -- the complete GhcPkgId (only a PackageIdentifier) in the configure -- options, just using the previous value is insufficient to know if -- dependencies have changed. , configCacheComponents :: !(Set S.ByteString) -- ^ The components to be built. It's a bit of a hack to include this in -- here, as it's not a configure option (just a build option), but this -- is a convenient way to force compilation when the components change. , configCacheHaddock :: !Bool -- ^ Are haddocks to be built? , configCachePkgSrc :: !CachePkgSrc } deriving (Generic, Eq, Show, Data, Typeable) instance Store ConfigCache instance NFData ConfigCache data CachePkgSrc = CacheSrcUpstream | CacheSrcLocal FilePath deriving (Generic, Eq, Show, Data, Typeable) instance Store CachePkgSrc instance NFData CachePkgSrc toCachePkgSrc :: PackageSource -> CachePkgSrc toCachePkgSrc (PSFiles lp _) = CacheSrcLocal (toFilePath (lpDir lp)) toCachePkgSrc PSIndex{} = CacheSrcUpstream configCacheVC :: VersionConfig ConfigCache configCacheVC = storeVersionConfig "config-v3" "z7N_NxX7Gbz41Gi9AGEa1zoLE-4=" -- | A task to perform when building data Task = Task { taskProvides :: !PackageIdentifier -- FIXME turn this into a function on taskType? -- ^ the package/version to be built , taskType :: !TaskType -- ^ the task type, telling us how to build this , taskConfigOpts :: !TaskConfigOpts , taskPresent :: !(Map PackageIdentifier GhcPkgId) -- ^ GhcPkgIds of already-installed dependencies , taskAllInOne :: !Bool -- ^ indicates that the package can be built in one step , taskCachePkgSrc :: !CachePkgSrc , taskAnyMissing :: !Bool -- ^ Were any of the dependencies missing? The reason this is -- necessary is... hairy. And as you may expect, a bug in -- Cabal. See: -- . The -- problem is that Cabal may end up generating the same package ID -- for a dependency, even if the ABI has changed. As a result, -- without this field, Stack would think that a reconfigure is -- unnecessary, when in fact we _do_ need to reconfigure. The -- details here suck. We really need proper hashes for package -- identifiers. , taskBuildTypeConfig :: !Bool -- ^ Is the build type of this package Configure. Check out -- ensureConfigureScript in Stack.Build.Execute for the motivation } deriving Show -- | Given the IDs of any missing packages, produce the configure options data TaskConfigOpts = TaskConfigOpts { tcoMissing :: !(Set PackageIdentifier) -- ^ Dependencies for which we don't yet have an GhcPkgId , tcoOpts :: !(Map PackageIdentifier GhcPkgId -> ConfigureOpts) -- ^ Produce the list of options given the missing @GhcPkgId@s } instance Show TaskConfigOpts where show (TaskConfigOpts missing f) = concat [ "Missing: " , show missing , ". Without those: " , show $ f Map.empty ] -- | The type of a task, either building local code or something from the -- package index (upstream) data TaskType = TTFiles LocalPackage InstallLocation | TTIndex Package InstallLocation PackageIdentifierRevision -- FIXME major overhaul for PackageLocation? deriving Show ttPackageLocation :: TaskType -> PackageLocationIndex FilePath ttPackageLocation (TTFiles lp _) = PLOther (lpLocation lp) ttPackageLocation (TTIndex _ _ pir) = PLIndex pir taskIsTarget :: Task -> Bool taskIsTarget t = case taskType t of TTFiles lp _ -> lpWanted lp _ -> False taskLocation :: Task -> InstallLocation taskLocation task = case taskType task of TTFiles _ loc -> loc TTIndex _ loc _ -> loc -- | A complete plan of what needs to be built and how to do it data Plan = Plan { planTasks :: !(Map PackageName Task) , planFinals :: !(Map PackageName Task) -- ^ Final actions to be taken (test, benchmark, etc) , planUnregisterLocal :: !(Map GhcPkgId (PackageIdentifier, Text)) -- ^ Text is reason we're unregistering, for display only , planInstallExes :: !(Map Text InstallLocation) -- ^ Executables that should be installed after successful building } deriving Show -- | Basic information used to calculate what the configure options are data BaseConfigOpts = BaseConfigOpts { bcoSnapDB :: !(Path Abs Dir) , bcoLocalDB :: !(Path Abs Dir) , bcoSnapInstallRoot :: !(Path Abs Dir) , bcoLocalInstallRoot :: !(Path Abs Dir) , bcoBuildOpts :: !BuildOpts , bcoBuildOptsCLI :: !BuildOptsCLI , bcoExtraDBs :: ![Path Abs Dir] } deriving Show -- | Render a @BaseConfigOpts@ to an actual list of options configureOpts :: EnvConfig -> BaseConfigOpts -> Map PackageIdentifier GhcPkgId -- ^ dependencies -> Bool -- ^ local non-extra-dep? -> InstallLocation -> Package -> ConfigureOpts configureOpts econfig bco deps isLocal loc package = ConfigureOpts { coDirs = configureOptsDirs bco loc package , coNoDirs = configureOptsNoDir econfig bco deps isLocal package } -- options set by stack isStackOpt :: Text -> Bool isStackOpt t = any (`T.isPrefixOf` t) [ "--dependency=" , "--constraint=" , "--package-db=" , "--libdir=" , "--bindir=" , "--datadir=" , "--libexecdir=" , "--sysconfdir" , "--docdir=" , "--htmldir=" , "--haddockdir=" , "--enable-tests" , "--enable-benchmarks" , "--exact-configuration" -- Treat these as causing dirtiness, to resolve -- https://github.com/commercialhaskell/stack/issues/2984 -- -- , "--enable-library-profiling" -- , "--enable-executable-profiling" -- , "--enable-profiling" ] || t == "--user" configureOptsDirs :: BaseConfigOpts -> InstallLocation -> Package -> [String] configureOptsDirs bco loc package = concat [ ["--user", "--package-db=clear", "--package-db=global"] , map (("--package-db=" ++) . toFilePathNoTrailingSep) $ case loc of Snap -> bcoExtraDBs bco ++ [bcoSnapDB bco] Local -> bcoExtraDBs bco ++ [bcoSnapDB bco] ++ [bcoLocalDB bco] , [ "--libdir=" ++ toFilePathNoTrailingSep (installRoot $(mkRelDir "lib")) , "--bindir=" ++ toFilePathNoTrailingSep (installRoot bindirSuffix) , "--datadir=" ++ toFilePathNoTrailingSep (installRoot $(mkRelDir "share")) , "--libexecdir=" ++ toFilePathNoTrailingSep (installRoot $(mkRelDir "libexec")) , "--sysconfdir=" ++ toFilePathNoTrailingSep (installRoot $(mkRelDir "etc")) , "--docdir=" ++ toFilePathNoTrailingSep docDir , "--htmldir=" ++ toFilePathNoTrailingSep docDir , "--haddockdir=" ++ toFilePathNoTrailingSep docDir] ] where installRoot = case loc of Snap -> bcoSnapInstallRoot bco Local -> bcoLocalInstallRoot bco docDir = case pkgVerDir of Nothing -> installRoot docDirSuffix Just dir -> installRoot docDirSuffix dir pkgVerDir = parseRelDir (packageIdentifierString (PackageIdentifier (packageName package) (packageVersion package)) ++ [pathSeparator]) -- | Same as 'configureOpts', but does not include directory path options configureOptsNoDir :: EnvConfig -> BaseConfigOpts -> Map PackageIdentifier GhcPkgId -- ^ dependencies -> Bool -- ^ is this a local, non-extra-dep? -> Package -> [String] configureOptsNoDir econfig bco deps isLocal package = concat [ depOptions , ["--enable-library-profiling" | boptsLibProfile bopts || boptsExeProfile bopts] -- Cabal < 1.21.1 does not support --enable-profiling, use --enable-executable-profiling instead , let profFlag = "--enable-" <> concat ["executable-" | not newerCabal] <> "profiling" in [ profFlag | boptsExeProfile bopts && isLocal] , ["--enable-split-objs" | boptsSplitObjs bopts] , ["--disable-library-stripping" | not $ boptsLibStrip bopts || boptsExeStrip bopts] , ["--disable-executable-stripping" | not (boptsExeStrip bopts) && isLocal] , map (\(name,enabled) -> "-f" <> (if enabled then "" else "-") <> flagNameString name) (Map.toList flags) , concatMap (\x -> [compilerOptionsCabalFlag wc, T.unpack x]) (packageGhcOptions package) , map ("--extra-include-dirs=" ++) (Set.toList (configExtraIncludeDirs config)) , map ("--extra-lib-dirs=" ++) (Set.toList (configExtraLibDirs config)) , maybe [] (\customGcc -> ["--with-gcc=" ++ toFilePath customGcc]) (configOverrideGccPath config) , ["--ghcjs" | wc == Ghcjs] , ["--exact-configuration" | useExactConf] ] where wc = view (actualCompilerVersionL.to whichCompiler) econfig config = view configL econfig bopts = bcoBuildOpts bco -- TODO: instead always enable this when the cabal version is new -- enough. That way we'll detect bugs with --exact-configuration -- earlier. Cabal also might do less work then. useExactConf = configAllowNewer config newerCabal = view cabalVersionL econfig >= $(mkVersion "1.22") -- Unioning atop defaults is needed so that all flags are specified -- with --exact-configuration. flags | useExactConf = packageFlags package `Map.union` packageDefaultFlags package | otherwise = packageFlags package depOptions = map (uncurry toDepOption) $ Map.toList deps where toDepOption = if newerCabal then toDepOption1_22 else toDepOption1_18 toDepOption1_22 ident gid = concat [ "--dependency=" , packageNameString $ packageIdentifierName ident , "=" , ghcPkgIdString gid ] toDepOption1_18 ident _gid = concat [ "--constraint=" , packageNameString name , "==" , versionString version' ] where PackageIdentifier name version' = ident -- | Get set of wanted package names from locals. wantedLocalPackages :: [LocalPackage] -> Set PackageName wantedLocalPackages = Set.fromList . map (packageName . lpPackage) . filter lpWanted -- | One-way conversion to serialized time. modTime :: UTCTime -> ModTime modTime x = ModTime ( toModifiedJulianDay (utctDay x) , toRational (utctDayTime x)) -- | Configure options to be sent to Setup.hs configure data ConfigureOpts = ConfigureOpts { coDirs :: ![String] -- ^ Options related to various paths. We separate these out since they do -- not have an impact on the contents of the compiled binary for checking -- if we can use an existing precompiled cache. , coNoDirs :: ![String] } deriving (Show, Eq, Generic, Data, Typeable) instance Store ConfigureOpts instance NFData ConfigureOpts -- | Information on a compiled package: the library conf file (if relevant), -- the sublibraries (if present) and all of the executable paths. data PrecompiledCache = PrecompiledCache -- Use FilePath instead of Path Abs File for Binary instances { pcLibrary :: !(Maybe FilePath) -- ^ .conf file inside the package database , pcSubLibs :: ![FilePath] -- ^ .conf file inside the package database, for each of the sublibraries , pcExes :: ![FilePath] -- ^ Full paths to executables } deriving (Show, Eq, Generic, Data, Typeable) instance Store PrecompiledCache instance NFData PrecompiledCache precompiledCacheVC :: VersionConfig PrecompiledCache #if MIN_VERSION_template_haskell(2,14,0) precompiledCacheVC = storeVersionConfig "precompiled-v2" "1Q08F5_iKDGDMPCuBG0-Av9nEKk=" #else precompiledCacheVC = storeVersionConfig "precompiled-v2" "55vMMtbIlS4UukKnSmjs1SrI01o=" #endif stack-1.9.3.1/src/Stack/Types/BuildPlan.hs0000644000000000000000000003766113455617610016351 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude #-} {-# LANGUAGE CPP #-} {-# LANGUAGE DataKinds #-} {-# LANGUAGE DeriveDataTypeable #-} {-# LANGUAGE DeriveFunctor #-} {-# LANGUAGE DeriveGeneric #-} {-# LANGUAGE GeneralizedNewtypeDeriving #-} {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE RecordWildCards #-} {-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE TupleSections #-} {-# LANGUAGE TypeFamilies #-} -- | Shared types for various stackage packages. module Stack.Types.BuildPlan ( -- * Types SnapshotDef (..) , snapshotDefVC , sdRawPathName , PackageLocation (..) , PackageLocationIndex (..) , RepoType (..) , Subdirs (..) , Repo (..) , Archive (..) , ExeName (..) , LoadedSnapshot (..) , loadedSnapshotVC , LoadedPackageInfo (..) , ModuleName (..) , fromCabalModuleName , ModuleInfo (..) , moduleInfoVC , setCompilerVersion , sdWantedCompilerVersion ) where import Data.Aeson (ToJSON (..), FromJSON (..), withText, object, (.=)) import Data.Aeson.Extended (WithJSONWarnings (..), (..:), (..:?), withObjectWarnings, noJSONWarnings, (..!=)) import qualified Data.Map as Map import qualified Data.Set as Set import Data.Store.Version import Data.Store.VersionTagged import qualified Data.Text as T import Data.Text.Encoding (encodeUtf8) import qualified Distribution.ModuleName as C import qualified Distribution.Version as C import Network.HTTP.StackClient (parseRequest) import Stack.Prelude import Stack.Types.Compiler import Stack.Types.FlagName import Stack.Types.GhcPkgId import Stack.Types.PackageIdentifier import Stack.Types.PackageName import Stack.Types.Resolver import Stack.Types.Version import Stack.Types.VersionIntervals -- | A definition of a snapshot. This could be a Stackage snapshot or -- something custom. It does not include information on the global -- package database, this is added later. -- -- It may seem more logic to attach flags, options, etc, directly with -- the desired package. However, this isn't possible yet: our -- definition may contain tarballs or Git repos, and we don't actually -- know the package names contained there. Therefore, we capture all -- of this additional information by package name, and later in the -- snapshot load step we will resolve the contents of tarballs and -- repos, figure out package names, and assigned values appropriately. data SnapshotDef = SnapshotDef { sdParent :: !(Either (CompilerVersion 'CVWanted) SnapshotDef) -- ^ The snapshot to extend from. This is either a specific -- compiler, or a @SnapshotDef@ which gives us more information -- (like packages). Ultimately, we'll end up with a -- @CompilerVersion@. , sdResolver :: !LoadedResolver -- ^ The resolver that provides this definition. , sdResolverName :: !Text -- ^ A user-friendly way of referring to this resolver. , sdLocations :: ![PackageLocationIndex Subdirs] -- ^ Where to grab all of the packages from. , sdDropPackages :: !(Set PackageName) -- ^ Packages present in the parent which should not be included -- here. , sdFlags :: !(Map PackageName (Map FlagName Bool)) -- ^ Flag values to override from the defaults , sdHidden :: !(Map PackageName Bool) -- ^ Packages which should be hidden when registering. This will -- affect, for example, the import parser in the script -- command. We use a 'Map' instead of just a 'Set' to allow -- overriding the hidden settings in a parent snapshot. , sdGhcOptions :: !(Map PackageName [Text]) -- ^ GHC options per package , sdGlobalHints :: !(Map PackageName (Maybe Version)) -- ^ Hints about which packages are available globally. When -- actually building code, we trust the package database provided -- by GHC itself, since it may be different based on platform or -- GHC install. However, when we want to check the compatibility -- of a snapshot with some codebase without installing GHC (e.g., -- during stack init), we would use this field. } deriving (Show, Eq, Data, Generic, Typeable) instance Store SnapshotDef instance NFData SnapshotDef snapshotDefVC :: VersionConfig SnapshotDef #if MIN_VERSION_template_haskell(2,14,0) snapshotDefVC = storeVersionConfig "sd-v1" "u-V-7pmU0YA-nXZFI0UBIST3JdY=" #else snapshotDefVC = storeVersionConfig "sd-v1" "CKo7nln8EXkw07Gq-4ATxszNZiE=" #endif -- | A relative file path including a unique string for the given -- snapshot. sdRawPathName :: SnapshotDef -> String sdRawPathName sd = T.unpack $ go $ sdResolver sd where go (ResolverStackage name) = renderSnapName name go (ResolverCompiler version) = compilerVersionText version go (ResolverCustom _ hash) = "custom-" <> sdResolverName sd <> "-" <> trimmedSnapshotHash hash -- | Modify the wanted compiler version in this snapshot. This is used -- when overriding via the `compiler` value in a custom snapshot or -- stack.yaml file. We do _not_ need to modify the snapshot's hash for -- this: all binary caches of a snapshot are stored in a filepath that -- encodes the actual compiler version in addition to the -- hash. Therefore, modifications here will not lead to any invalid -- data. setCompilerVersion :: CompilerVersion 'CVWanted -> SnapshotDef -> SnapshotDef setCompilerVersion cv = go where go sd = case sdParent sd of Left _ -> sd { sdParent = Left cv } Right sd' -> sd { sdParent = Right $ go sd' } -- | Where to get the contents of a package (including cabal file -- revisions) from. -- -- A GADT may be more logical than the index parameter, but this plays -- more nicely with Generic deriving. data PackageLocation subdirs = PLFilePath !FilePath -- ^ Note that we use @FilePath@ and not @Path@s. The goal is: first parse -- the value raw, and then use @canonicalizePath@ and @parseAbsDir@. | PLArchive !(Archive subdirs) | PLRepo !(Repo subdirs) -- ^ Stored in a source control repository deriving (Generic, Show, Eq, Ord, Data, Typeable, Functor) instance (Store a) => Store (PackageLocation a) instance (NFData a) => NFData (PackageLocation a) -- | Add in the possibility of getting packages from the index -- (including cabal file revisions). We have special handling of this -- case in many places in the codebase, and therefore represent it -- with a separate data type from 'PackageLocation'. data PackageLocationIndex subdirs = PLIndex !PackageIdentifierRevision -- ^ Grab the package from the package index with the given -- version and (optional) cabal file info to specify the correct -- revision. | PLOther !(PackageLocation subdirs) deriving (Generic, Show, Eq, Ord, Data, Typeable, Functor) instance (Store a) => Store (PackageLocationIndex a) instance (NFData a) => NFData (PackageLocationIndex a) -- | A package archive, could be from a URL or a local file -- path. Local file path archives are assumed to be unchanging -- over time, and so are allowed in custom snapshots. data Archive subdirs = Archive { archiveUrl :: !Text , archiveSubdirs :: !subdirs , archiveHash :: !(Maybe StaticSHA256) } deriving (Generic, Show, Eq, Ord, Data, Typeable, Functor) instance Store a => Store (Archive a) instance NFData a => NFData (Archive a) -- | The type of a source control repository. data RepoType = RepoGit | RepoHg deriving (Generic, Show, Eq, Ord, Data, Typeable) instance Store RepoType instance NFData RepoType data Subdirs = DefaultSubdirs | ExplicitSubdirs ![FilePath] deriving (Generic, Show, Eq, Data, Typeable) instance Store Subdirs instance NFData Subdirs instance FromJSON Subdirs where parseJSON = fmap ExplicitSubdirs . parseJSON -- | Information on packages stored in a source control repository. data Repo subdirs = Repo { repoUrl :: !Text , repoCommit :: !Text , repoType :: !RepoType , repoSubdirs :: !subdirs } deriving (Generic, Show, Eq, Ord, Data, Typeable, Functor) instance Store a => Store (Repo a) instance NFData a => NFData (Repo a) instance subdirs ~ Subdirs => ToJSON (PackageLocationIndex subdirs) where toJSON (PLIndex ident) = toJSON ident toJSON (PLOther loc) = toJSON loc instance subdirs ~ Subdirs => ToJSON (PackageLocation subdirs) where toJSON (PLFilePath fp) = toJSON fp toJSON (PLArchive (Archive t DefaultSubdirs Nothing)) = toJSON t toJSON (PLArchive (Archive t subdirs msha)) = object $ concat [ ["location" .= t] , case subdirs of DefaultSubdirs -> [] ExplicitSubdirs x -> ["subdirs" .= x] , case msha of Nothing -> [] Just sha -> ["sha256" .= staticSHA256ToText sha] ] toJSON (PLRepo (Repo url commit typ subdirs)) = object $ concat [ case subdirs of DefaultSubdirs -> [] ExplicitSubdirs x -> ["subdirs" .= x] , [urlKey .= url] , ["commit" .= commit] ] where urlKey = case typ of RepoGit -> "git" RepoHg -> "hg" instance subdirs ~ Subdirs => FromJSON (WithJSONWarnings (PackageLocationIndex subdirs)) where parseJSON v = (noJSONWarnings . PLIndex <$> parseJSON v) <|> (fmap PLOther <$> parseJSON v) instance subdirs ~ Subdirs => FromJSON (WithJSONWarnings (PackageLocation subdirs)) where parseJSON v = (noJSONWarnings <$> withText "PackageLocation" (\t -> http t <|> file t) v) <|> repo v <|> archiveObject v <|> github v where file t = pure $ PLFilePath $ T.unpack t http t = case parseRequest $ T.unpack t of Left _ -> fail $ "Could not parse URL: " ++ T.unpack t Right _ -> return $ PLArchive $ Archive t DefaultSubdirs Nothing repo = withObjectWarnings "PLRepo" $ \o -> do (repoType, repoUrl) <- ((RepoGit, ) <$> o ..: "git") <|> ((RepoHg, ) <$> o ..: "hg") repoCommit <- o ..: "commit" repoSubdirs <- o ..:? "subdirs" ..!= DefaultSubdirs return $ PLRepo Repo {..} archiveObject = withObjectWarnings "PLArchive" $ \o -> do url <- o ..: "archive" subdirs <- o ..:? "subdirs" ..!= DefaultSubdirs msha <- o ..:? "sha256" msha' <- case msha of Nothing -> return Nothing Just t -> case mkStaticSHA256FromText t of Left e -> fail $ "Invalid SHA256: " ++ T.unpack t ++ ", " ++ show e Right x -> return $ Just x return $ PLArchive Archive { archiveUrl = url , archiveSubdirs = subdirs :: Subdirs , archiveHash = msha' } github = withObjectWarnings "PLArchive:github" $ \o -> do GitHubRepo ghRepo <- o ..: "github" commit <- o ..: "commit" subdirs <- o ..:? "subdirs" ..!= DefaultSubdirs return $ PLArchive Archive { archiveUrl = "https://github.com/" <> ghRepo <> "/archive/" <> commit <> ".tar.gz" , archiveSubdirs = subdirs , archiveHash = Nothing } -- An unexported newtype wrapper to hang a 'FromJSON' instance off of. Contains -- a GitHub user and repo name separated by a forward slash, e.g. "foo/bar". newtype GitHubRepo = GitHubRepo Text instance FromJSON GitHubRepo where parseJSON = withText "GitHubRepo" $ \s -> do case T.split (== '/') s of [x, y] | not (T.null x || T.null y) -> return (GitHubRepo s) _ -> fail "expecting \"user/repo\"" -- | Name of an executable. newtype ExeName = ExeName { unExeName :: Text } deriving (Show, Eq, Ord, Hashable, IsString, Generic, Store, NFData, Data, Typeable) -- | A fully loaded snapshot combined , including information gleaned from the -- global database and parsing cabal files. -- -- Invariant: a global package may not depend upon a snapshot package, -- a snapshot may not depend upon a local or project, and all -- dependencies must be satisfied. data LoadedSnapshot = LoadedSnapshot { lsCompilerVersion :: !(CompilerVersion 'CVActual) , lsGlobals :: !(Map PackageName (LoadedPackageInfo GhcPkgId)) , lsPackages :: !(Map PackageName (LoadedPackageInfo (PackageLocationIndex FilePath))) } deriving (Generic, Show, Data, Eq, Typeable) instance Store LoadedSnapshot instance NFData LoadedSnapshot loadedSnapshotVC :: VersionConfig LoadedSnapshot #if MIN_VERSION_template_haskell(2,14,0) loadedSnapshotVC = storeVersionConfig "ls-v5" "Rl-3KjZ1LqhIyGy-o0HCC-I6cRc=" #else loadedSnapshotVC = storeVersionConfig "ls-v5" "CeSRWh1VU8v0__kwA__msbe6WlU=" #endif -- | Information on a single package for the 'LoadedSnapshot' which -- can be installed. -- -- Note that much of the information below (such as the package -- dependencies or exposed modules) can be conditional in the cabal -- file, which means it will vary based on flags, arch, and OS. data LoadedPackageInfo loc = LoadedPackageInfo { lpiVersion :: !Version -- ^ This /must/ match the version specified within 'rpiDef'. , lpiLocation :: !loc -- ^ Where to get the package from. This could be a few different -- things: -- -- * For a global package, it will be the @GhcPkgId@. (If we end -- up needing to rebuild this because we've changed a -- dependency, we will take it from the package index with no -- @CabalFileInfo@. -- -- * For a dependency, it will be a @PackageLocation@. -- -- * For a project package, it will be a @Path Abs Dir@. , lpiFlags :: !(Map FlagName Bool) -- ^ Flags to build this package with. , lpiGhcOptions :: ![Text] -- ^ GHC options to use when building this package. , lpiPackageDeps :: !(Map PackageName VersionIntervals) -- ^ All packages which must be built/copied/registered before -- this package. , lpiExposedModules :: !(Set ModuleName) -- ^ Modules exposed by this package's library , lpiHide :: !Bool -- ^ Should this package be hidden in the database. Affects the -- script interpreter's module name import parser. } deriving (Generic, Show, Eq, Data, Typeable, Functor) instance Store a => Store (LoadedPackageInfo a) instance NFData a => NFData (LoadedPackageInfo a) data DepInfo = DepInfo { _diComponents :: !(Set Component) , _diRange :: !VersionIntervals } deriving (Generic, Show, Eq, Data, Typeable) instance Store DepInfo instance NFData DepInfo instance Semigroup DepInfo where DepInfo a x <> DepInfo b y = DepInfo (mappend a b) (intersectVersionIntervals x y) instance Monoid DepInfo where mempty = DepInfo mempty (fromVersionRange C.anyVersion) mappend = (<>) data Component = CompLibrary | CompExecutable | CompTestSuite | CompBenchmark deriving (Generic, Show, Eq, Ord, Data, Typeable, Enum, Bounded) instance Store Component instance NFData Component newtype ModuleName = ModuleName { unModuleName :: ByteString } deriving (Show, Eq, Ord, Generic, Store, NFData, Typeable, Data) fromCabalModuleName :: C.ModuleName -> ModuleName fromCabalModuleName = ModuleName . encodeUtf8 . T.intercalate "." . map T.pack . C.components newtype ModuleInfo = ModuleInfo { miModules :: Map ModuleName (Set PackageName) } deriving (Show, Eq, Ord, Generic, Typeable, Data) instance Store ModuleInfo instance NFData ModuleInfo instance Semigroup ModuleInfo where ModuleInfo x <> ModuleInfo y = ModuleInfo (Map.unionWith Set.union x y) instance Monoid ModuleInfo where mempty = ModuleInfo mempty mappend = (<>) moduleInfoVC :: VersionConfig ModuleInfo moduleInfoVC = storeVersionConfig "mi-v2" "8ImAfrwMVmqoSoEpt85pLvFeV3s=" -- | Determined the desired compiler version for this 'SnapshotDef'. sdWantedCompilerVersion :: SnapshotDef -> CompilerVersion 'CVWanted sdWantedCompilerVersion = either id sdWantedCompilerVersion . sdParent stack-1.9.3.1/src/Stack/Types/CompilerBuild.hs0000644000000000000000000000250713312026775017216 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude #-} module Stack.Types.CompilerBuild (CompilerBuild(..) ,compilerBuildName ,compilerBuildSuffix ,parseCompilerBuild ) where import Stack.Prelude import Data.Aeson.Extended (FromJSON, parseJSON, withText) import Data.Text as T data CompilerBuild = CompilerBuildStandard | CompilerBuildSpecialized String deriving (Show) instance FromJSON CompilerBuild where -- Strange structuring is to give consistent error messages parseJSON = withText "CompilerBuild" (either (fail . show) return . parseCompilerBuild . T.unpack) -- | Descriptive name for compiler build compilerBuildName :: CompilerBuild -> String compilerBuildName CompilerBuildStandard = "standard" compilerBuildName (CompilerBuildSpecialized s) = s -- | Suffix to use for filenames/directories constructed with compiler build compilerBuildSuffix :: CompilerBuild -> String compilerBuildSuffix CompilerBuildStandard = "" compilerBuildSuffix (CompilerBuildSpecialized s) = '-' : s -- | Parse compiler build from a String. parseCompilerBuild :: (MonadThrow m) => String -> m CompilerBuild parseCompilerBuild "" = return CompilerBuildStandard parseCompilerBuild "standard" = return CompilerBuildStandard parseCompilerBuild name = return (CompilerBuildSpecialized name) stack-1.9.3.1/src/Stack/Types/Urls.hs0000644000000000000000000000244013455617610015407 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude #-} {-# LANGUAGE DeriveGeneric #-} {-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE OverloadedStrings #-} module Stack.Types.Urls where import Data.Aeson.Extended import Generics.Deriving.Monoid (memptydefault, mappenddefault) import Stack.Prelude data Urls = Urls { urlsLatestSnapshot :: !Text , urlsLtsBuildPlans :: !Text , urlsNightlyBuildPlans :: !Text } deriving Show -- TODO: Really need this instance? instance FromJSON (WithJSONWarnings Urls) where parseJSON = withObjectWarnings "Urls" $ \o -> do Urls <$> o ..: "latest-snapshot" <*> o ..: "lts-build-plans" <*> o ..: "nightly-build-plans" data UrlsMonoid = UrlsMonoid { urlsMonoidLatestSnapshot :: !(First Text) , urlsMonoidLtsBuildPlans :: !(First Text) , urlsMonoidNightlyBuildPlans :: !(First Text) } deriving (Show, Generic) instance FromJSON (WithJSONWarnings UrlsMonoid) where parseJSON = withObjectWarnings "UrlsMonoid" $ \o -> do UrlsMonoid <$> o ..: "latest-snapshot" <*> o ..: "lts-build-plans" <*> o ..: "nightly-build-plans" instance Semigroup UrlsMonoid where (<>) = mappenddefault instance Monoid UrlsMonoid where mempty = memptydefault mappend = (<>) stack-1.9.3.1/src/Stack/Types/Compiler.hs0000644000000000000000000000764513455666157016262 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude #-} {-# LANGUAGE DataKinds #-} {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE DeriveDataTypeable #-} {-# LANGUAGE DeriveGeneric #-} {-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE KindSignatures #-} {-# LANGUAGE TypeFamilies #-} module Stack.Types.Compiler where import Data.Aeson import Data.Data import qualified Data.Text as T import Stack.Prelude import Stack.Types.Version -- | Variety of compiler to use. data WhichCompiler = Ghc | Ghcjs deriving (Show, Eq, Ord) -- | Whether the compiler version given is the wanted version (what -- the stack.yaml file, snapshot file, or --resolver argument -- request), or the actual installed GHC. Depending on the matching -- requirements, these values could be different. data CVType = CVWanted | CVActual -- | Specifies a compiler and its version number(s). -- -- Note that despite having this datatype, stack isn't in a hurry to -- support compilers other than GHC. data CompilerVersion (cvType :: CVType) = GhcVersion {-# UNPACK #-} !Version | GhcjsVersion {-# UNPACK #-} !Version -- GHCJS version {-# UNPACK #-} !Version -- GHC version deriving (Generic, Show, Eq, Ord, Data, Typeable) instance Store (CompilerVersion a) instance NFData (CompilerVersion a) instance Display (CompilerVersion a) where display = display . compilerVersionText instance ToJSON (CompilerVersion a) where toJSON = toJSON . compilerVersionText instance FromJSON (CompilerVersion a) where parseJSON (String t) = maybe (fail "Failed to parse compiler version") return (parseCompilerVersion t) parseJSON _ = fail "Invalid CompilerVersion, must be String" instance FromJSONKey (CompilerVersion a) where fromJSONKey = FromJSONKeyTextParser $ \k -> case parseCompilerVersion k of Nothing -> fail $ "Failed to parse CompilerVersion " ++ T.unpack k Just parsed -> return parsed actualToWanted :: CompilerVersion 'CVActual -> CompilerVersion 'CVWanted actualToWanted (GhcVersion x) = GhcVersion x actualToWanted (GhcjsVersion x y) = GhcjsVersion x y wantedToActual :: CompilerVersion 'CVWanted -> CompilerVersion 'CVActual wantedToActual (GhcVersion x) = GhcVersion x wantedToActual (GhcjsVersion x y) = GhcjsVersion x y parseCompilerVersion :: T.Text -> Maybe (CompilerVersion a) parseCompilerVersion t | Just t' <- T.stripPrefix "ghc-" t , Just v <- parseVersionFromString $ T.unpack t' = Just (GhcVersion v) | Just t' <- T.stripPrefix "ghcjs-" t , [tghcjs, tghc] <- T.splitOn "_ghc-" t' , Just vghcjs <- parseVersionFromString $ T.unpack tghcjs , Just vghc <- parseVersionFromString $ T.unpack tghc = Just (GhcjsVersion vghcjs vghc) | otherwise = Nothing compilerVersionText :: CompilerVersion a -> T.Text compilerVersionText (GhcVersion vghc) = "ghc-" <> versionText vghc compilerVersionText (GhcjsVersion vghcjs vghc) = "ghcjs-" <> versionText vghcjs <> "_ghc-" <> versionText vghc compilerVersionString :: CompilerVersion a -> String compilerVersionString = T.unpack . compilerVersionText whichCompiler :: CompilerVersion a -> WhichCompiler whichCompiler GhcVersion {} = Ghc whichCompiler GhcjsVersion {} = Ghcjs isWantedCompiler :: VersionCheck -> CompilerVersion 'CVWanted -> CompilerVersion 'CVActual -> Bool isWantedCompiler check (GhcVersion wanted) (GhcVersion actual) = checkVersion check wanted actual isWantedCompiler check (GhcjsVersion wanted wantedGhc) (GhcjsVersion actual actualGhc) = checkVersion check wanted actual && checkVersion check wantedGhc actualGhc isWantedCompiler _ _ _ = False getGhcVersion :: CompilerVersion a -> Version getGhcVersion (GhcVersion v) = v getGhcVersion (GhcjsVersion _ v) = v compilerExeName :: WhichCompiler -> String compilerExeName Ghc = "ghc" compilerExeName Ghcjs = "ghcjs" haddockExeName :: WhichCompiler -> String haddockExeName Ghc = "haddock" haddockExeName Ghcjs = "haddock-ghcjs" stack-1.9.3.1/src/Stack/Types/Config.hs0000644000000000000000000023673613455671116015711 0ustar0000000000000000{-# LANGUAGE CPP #-} {-# LANGUAGE ConstraintKinds #-} {-# LANGUAGE DataKinds #-} {-# LANGUAGE DefaultSignatures #-} {-# LANGUAGE DeriveDataTypeable #-} {-# LANGUAGE DeriveFoldable #-} {-# LANGUAGE DeriveFunctor #-} {-# LANGUAGE DeriveGeneric #-} {-# LANGUAGE DeriveTraversable #-} {-# LANGUAGE FlexibleContexts #-} {-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE GADTs #-} {-# LANGUAGE GeneralizedNewtypeDeriving #-} {-# LANGUAGE MultiParamTypeClasses #-} {-# LANGUAGE MultiWayIf #-} {-# LANGUAGE NoImplicitPrelude #-} {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE RecordWildCards #-} {-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE StandaloneDeriving #-} {-# LANGUAGE TemplateHaskell #-} {-# LANGUAGE TupleSections #-} {-# LANGUAGE TypeFamilies #-} -- | The Config type. module Stack.Types.Config ( -- * Main configuration types and classes -- ** HasPlatform & HasStackRoot HasPlatform(..) ,PlatformVariant(..) -- ** Config & HasConfig ,Config(..) ,HasConfig(..) ,askLatestSnapshotUrl ,explicitSetupDeps -- ** BuildConfig & HasBuildConfig ,BuildConfig(..) ,LocalPackages(..) ,LocalPackageView(..) ,lpvRoot ,lpvName ,lpvVersion ,lpvComponents ,stackYamlL ,projectRootL ,HasBuildConfig(..) -- ** GHCVariant & HasGHCVariant ,GHCVariant(..) ,ghcVariantName ,ghcVariantSuffix ,parseGHCVariant ,HasGHCVariant(..) ,snapshotsDir -- ** EnvConfig & HasEnvConfig ,EnvConfig(..) ,HasEnvConfig(..) ,getCompilerPath -- * Details -- ** ApplyGhcOptions ,ApplyGhcOptions(..) -- ** ConfigException ,HpackExecutable(..) ,ConfigException(..) -- ** WhichSolverCmd ,WhichSolverCmd(..) -- ** ConfigMonoid ,ConfigMonoid(..) ,configMonoidInstallGHCName ,configMonoidSystemGHCName ,parseConfigMonoid -- ** DumpLogs ,DumpLogs(..) -- ** EnvSettings ,EnvSettings(..) ,minimalEnvSettings ,defaultEnvSettings ,plainEnvSettings -- ** GlobalOpts & GlobalOptsMonoid ,GlobalOpts(..) ,GlobalOptsMonoid(..) ,StackYamlLoc(..) ,defaultLogLevel -- ** LoadConfig ,LoadConfig(..) -- ** PackageIndex, IndexName & IndexLocation -- Re-exports ,PackageIndex(..) ,IndexName(..) ,indexNameText -- ** Project & ProjectAndConfigMonoid ,Project(..) ,ProjectAndConfigMonoid(..) ,parseProjectAndConfigMonoid -- ** PvpBounds ,PvpBounds(..) ,PvpBoundsType(..) ,parsePvpBounds -- ** ColorWhen ,readColorWhen -- ** SCM ,SCM(..) -- * Paths ,bindirSuffix ,configInstalledCache ,configLoadedSnapshotCache ,GlobalInfoSource(..) ,getProjectWorkDir ,docDirSuffix ,flagCacheLocal ,extraBinDirs ,hpcReportDir ,installationRootDeps ,installationRootLocal ,bindirCompilerTools ,hoogleRoot ,hoogleDatabasePath ,packageDatabaseDeps ,packageDatabaseExtra ,packageDatabaseLocal ,platformOnlyRelDir ,platformGhcRelDir ,platformGhcVerOnlyRelDir ,useShaPathOnWindows ,shaPath ,shaPathForBytes ,workDirL -- * Command-specific types -- ** Eval ,EvalOpts(..) -- ** Exec ,ExecOpts(..) ,SpecialExecCmd(..) ,ExecOptsExtra(..) -- ** Setup ,DownloadInfo(..) ,VersionedDownloadInfo(..) ,GHCDownloadInfo(..) ,SetupInfo(..) ,SetupInfoLocation(..) -- ** Docker entrypoint ,DockerEntrypoint(..) ,DockerUser(..) ,module X -- * Lens helpers ,wantedCompilerVersionL ,actualCompilerVersionL ,buildOptsL ,globalOptsL ,buildOptsInstallExesL ,buildOptsMonoidHaddockL ,buildOptsMonoidTestsL ,buildOptsMonoidBenchmarksL ,buildOptsMonoidInstallExesL ,buildOptsHaddockL ,globalOptsBuildOptsMonoidL ,stackRootL ,configUrlsL ,cabalVersionL ,whichCompilerL ,envOverrideSettingsL ,loadedSnapshotL ,globalHintsL ,shouldForceGhcColorFlag ,appropriateGhcColorFlag -- * Lens reexport ,view ,to ) where import Control.Monad.Writer (tell) import Crypto.Hash (hashWith, SHA1(..)) import Stack.Prelude import Data.Aeson.Extended (ToJSON, toJSON, FromJSON, FromJSONKey (..), parseJSON, withText, object, (.=), (..:), (..:?), (..!=), Value(Bool, String), withObjectWarnings, WarningParser, Object, jsonSubWarnings, jsonSubWarningsT, jsonSubWarningsTT, WithJSONWarnings(..), noJSONWarnings, FromJSONKeyFunction (FromJSONKeyTextParser)) import Data.Attoparsec.Args (parseArgs, EscapingMode (Escaping)) import qualified Data.ByteArray.Encoding as Mem (convertToBase, Base(Base16)) import qualified Data.ByteString.Char8 as S8 import Data.Coerce (coerce) import Data.List (stripPrefix) import Data.List.NonEmpty (NonEmpty) import qualified Data.List.NonEmpty as NonEmpty import qualified Data.Map as Map import qualified Data.Map.Strict as M import qualified Data.Monoid as Monoid import Data.Monoid.Map (MonoidMap(..)) import qualified Data.Set as Set import qualified Data.Text as T import Data.Text.Encoding (encodeUtf8) import Data.Yaml (ParseException) import qualified Data.Yaml as Yaml import Distribution.PackageDescription (GenericPackageDescription) import qualified Distribution.PackageDescription as C import Distribution.System (Platform) import qualified Distribution.Text import qualified Distribution.Types.UnqualComponentName as C import Distribution.Version (anyVersion, mkVersion') import Generics.Deriving.Monoid (memptydefault, mappenddefault) import Lens.Micro (Lens', lens, _1, _2, to) import Options.Applicative (ReadM) import qualified Options.Applicative as OA import qualified Options.Applicative.Types as OA import Path import qualified Paths_stack as Meta import Stack.Constants import Stack.PackageIndex (HasCabalLoader (..), CabalLoader (clStackRoot)) import Stack.Types.BuildPlan import Stack.Types.Compiler import Stack.Types.CompilerBuild import Stack.Types.Docker import Stack.Types.FlagName import Stack.Types.Image import Stack.Types.NamedComponent import Stack.Types.Nix import Stack.Types.PackageIdentifier import Stack.Types.PackageIndex import Stack.Types.PackageName import Stack.Types.Resolver import Stack.Types.Runner import Stack.Types.TemplateName import Stack.Types.Urls import Stack.Types.Version import qualified System.FilePath as FilePath import System.PosixCompat.Types (UserID, GroupID, FileMode) import RIO.Process (ProcessContext, HasProcessContext (..), findExecutable) -- Re-exports import Stack.Types.Config.Build as X -- | The top-level Stackage configuration. data Config = Config {configWorkDir :: !(Path Rel Dir) -- ^ this allows to override .stack-work directory ,configUserConfigPath :: !(Path Abs File) -- ^ Path to user configuration file (usually ~/.stack/config.yaml) ,configBuild :: !BuildOpts -- ^ Build configuration ,configDocker :: !DockerOpts -- ^ Docker configuration ,configNix :: !NixOpts -- ^ Execution environment (e.g nix-shell) configuration ,configProcessContextSettings :: !(EnvSettings -> IO ProcessContext) -- ^ Environment variables to be passed to external tools ,configLocalProgramsBase :: !(Path Abs Dir) -- ^ Non-platform-specific path containing local installations ,configLocalPrograms :: !(Path Abs Dir) -- ^ Path containing local installations (mainly GHC) ,configHideTHLoading :: !Bool -- ^ Hide the Template Haskell "Loading package ..." messages from the -- console ,configPlatform :: !Platform -- ^ The platform we're building for, used in many directory names ,configPlatformVariant :: !PlatformVariant -- ^ Variant of the platform, also used in directory names ,configGHCVariant0 :: !(Maybe GHCVariant) -- ^ The variant of GHC requested by the user. -- In most cases, use 'BuildConfig' or 'MiniConfig's version instead, -- which will have an auto-detected default. ,configGHCBuild :: !(Maybe CompilerBuild) -- ^ Override build of the compiler distribution (e.g. standard, gmp4, tinfo6) ,configUrls :: !Urls -- ^ URLs for other files used by stack. -- TODO: Better document -- e.g. The latest snapshot file. -- A build plan name (e.g. lts5.9.yaml) is appended when downloading -- the build plan actually. ,configSystemGHC :: !Bool -- ^ Should we use the system-installed GHC (on the PATH) if -- available? Can be overridden by command line options. ,configInstallGHC :: !Bool -- ^ Should we automatically install GHC if missing or the wrong -- version is available? Can be overridden by command line options. ,configSkipGHCCheck :: !Bool -- ^ Don't bother checking the GHC version or architecture. ,configSkipMsys :: !Bool -- ^ On Windows: don't use a sandboxed MSYS ,configCompilerCheck :: !VersionCheck -- ^ Specifies which versions of the compiler are acceptable. ,configLocalBin :: !(Path Abs Dir) -- ^ Directory we should install executables into ,configRequireStackVersion :: !VersionRange -- ^ Require a version of stack within this range. ,configJobs :: !Int -- ^ How many concurrent jobs to run, defaults to number of capabilities ,configOverrideGccPath :: !(Maybe (Path Abs File)) -- ^ Optional gcc override path ,configOverrideHpack :: !HpackExecutable -- ^ Use Hpack executable (overrides bundled Hpack) ,configExtraIncludeDirs :: !(Set FilePath) -- ^ --extra-include-dirs arguments ,configExtraLibDirs :: !(Set FilePath) -- ^ --extra-lib-dirs arguments ,configConcurrentTests :: !Bool -- ^ Run test suites concurrently ,configImage :: !ImageOpts ,configTemplateParams :: !(Map Text Text) -- ^ Parameters for templates. ,configScmInit :: !(Maybe SCM) -- ^ Initialize SCM (e.g. git) when creating new projects. ,configGhcOptionsByName :: !(Map PackageName [Text]) -- ^ Additional GHC options to apply to specific packages. ,configGhcOptionsByCat :: !(Map ApplyGhcOptions [Text]) -- ^ Additional GHC options to apply to categories of packages ,configSetupInfoLocations :: ![SetupInfoLocation] -- ^ Additional SetupInfo (inline or remote) to use to find tools. ,configPvpBounds :: !PvpBounds -- ^ How PVP upper bounds should be added to packages ,configModifyCodePage :: !Bool -- ^ Force the code page to UTF-8 on Windows ,configExplicitSetupDeps :: !(Map (Maybe PackageName) Bool) -- ^ See 'explicitSetupDeps'. 'Nothing' provides the default value. ,configRebuildGhcOptions :: !Bool -- ^ Rebuild on GHC options changes ,configApplyGhcOptions :: !ApplyGhcOptions -- ^ Which packages to ghc-options on the command line apply to? ,configAllowNewer :: !Bool -- ^ Ignore version ranges in .cabal files. Funny naming chosen to -- match cabal. ,configDefaultTemplate :: !(Maybe TemplateName) -- ^ The default template to use when none is specified. -- (If Nothing, the default default is used.) ,configAllowDifferentUser :: !Bool -- ^ Allow users other than the stack root owner to use the stack -- installation. ,configDumpLogs :: !DumpLogs -- ^ Dump logs of local non-dependencies when doing a build. ,configMaybeProject :: !(Maybe (Project, Path Abs File)) -- ^ 'Just' when a local project can be found, 'Nothing' when stack must -- fall back on the implicit global project. ,configAllowLocals :: !Bool -- ^ Are we allowed to build local packages? The script -- command disallows this. ,configSaveHackageCreds :: !Bool -- ^ Should we save Hackage credentials to a file? ,configHackageBaseUrl :: !Text -- ^ Hackage base URL used when uploading packages ,configRunner :: !Runner ,configCabalLoader :: !CabalLoader } data HpackExecutable = HpackBundled | HpackCommand String deriving (Show, Read, Eq, Ord) -- | Which packages do ghc-options on the command line apply to? data ApplyGhcOptions = AGOTargets -- ^ all local targets | AGOLocals -- ^ all local packages, even non-targets | AGOEverything -- ^ every package deriving (Show, Read, Eq, Ord, Enum, Bounded) instance FromJSON ApplyGhcOptions where parseJSON = withText "ApplyGhcOptions" $ \t -> case t of "targets" -> return AGOTargets "locals" -> return AGOLocals "everything" -> return AGOEverything _ -> fail $ "Invalid ApplyGhcOptions: " ++ show t -- | Which build log files to dump data DumpLogs = DumpNoLogs -- ^ don't dump any logfiles | DumpWarningLogs -- ^ dump logfiles containing warnings | DumpAllLogs -- ^ dump all logfiles deriving (Show, Read, Eq, Ord, Enum, Bounded) instance FromJSON DumpLogs where parseJSON (Bool True) = return DumpAllLogs parseJSON (Bool False) = return DumpNoLogs parseJSON v = withText "DumpLogs" (\t -> if | t == "none" -> return DumpNoLogs | t == "warning" -> return DumpWarningLogs | t == "all" -> return DumpAllLogs | otherwise -> fail ("Invalid DumpLogs: " ++ show t)) v -- | Controls which version of the environment is used data EnvSettings = EnvSettings { esIncludeLocals :: !Bool -- ^ include local project bin directory, GHC_PACKAGE_PATH, etc , esIncludeGhcPackagePath :: !Bool -- ^ include the GHC_PACKAGE_PATH variable , esStackExe :: !Bool -- ^ set the STACK_EXE variable to the current executable name , esLocaleUtf8 :: !Bool -- ^ set the locale to C.UTF-8 , esKeepGhcRts :: !Bool -- ^ if True, keep GHCRTS variable in environment } deriving (Show, Eq, Ord) data ExecOpts = ExecOpts { eoCmd :: !SpecialExecCmd , eoArgs :: ![String] , eoExtra :: !ExecOptsExtra } deriving (Show) data SpecialExecCmd = ExecCmd String | ExecRun | ExecGhc | ExecRunGhc deriving (Show, Eq) data ExecOptsExtra = ExecOptsPlain | ExecOptsEmbellished { eoEnvSettings :: !EnvSettings , eoPackages :: ![String] , eoRtsOptions :: ![String] , eoCwd :: !(Maybe FilePath) } deriving (Show) data EvalOpts = EvalOpts { evalArg :: !String , evalExtra :: !ExecOptsExtra } deriving (Show) -- | Parsed global command-line options. data GlobalOpts = GlobalOpts { globalReExecVersion :: !(Maybe String) -- ^ Expected re-exec in container version , globalDockerEntrypoint :: !(Maybe DockerEntrypoint) -- ^ Data used when stack is acting as a Docker entrypoint (internal use only) , globalLogLevel :: !LogLevel -- ^ Log level , globalTimeInLog :: !Bool -- ^ Whether to include timings in logs. , globalConfigMonoid :: !ConfigMonoid -- ^ Config monoid, for passing into 'loadConfig' , globalResolver :: !(Maybe AbstractResolver) -- ^ Resolver override , globalCompiler :: !(Maybe (CompilerVersion 'CVWanted)) -- ^ Compiler override , globalTerminal :: !Bool -- ^ We're in a terminal? , globalColorWhen :: !ColorWhen -- ^ When to use ansi terminal colors , globalTermWidth :: !(Maybe Int) -- ^ Terminal width override , globalStackYaml :: !(StackYamlLoc FilePath) -- ^ Override project stack.yaml } deriving (Show) data StackYamlLoc filepath = SYLDefault | SYLOverride !filepath | SYLNoConfig !(Path Abs Dir) -- ^ FilePath is the directory containing the script file, used -- for resolving custom snapshot files. deriving (Show,Functor,Foldable,Traversable) -- | Parsed global command-line options monoid. data GlobalOptsMonoid = GlobalOptsMonoid { globalMonoidReExecVersion :: !(First String) -- ^ Expected re-exec in container version , globalMonoidDockerEntrypoint :: !(First DockerEntrypoint) -- ^ Data used when stack is acting as a Docker entrypoint (internal use only) , globalMonoidLogLevel :: !(First LogLevel) -- ^ Log level , globalMonoidTimeInLog :: !(First Bool) -- ^ Whether to include timings in logs. , globalMonoidConfigMonoid :: !ConfigMonoid -- ^ Config monoid, for passing into 'loadConfig' , globalMonoidResolver :: !(First AbstractResolver) -- ^ Resolver override , globalMonoidCompiler :: !(First (CompilerVersion 'CVWanted)) -- ^ Compiler override , globalMonoidTerminal :: !(First Bool) -- ^ We're in a terminal? , globalMonoidColorWhen :: !(First ColorWhen) -- ^ When to use ansi colors , globalMonoidTermWidth :: !(First Int) -- ^ Terminal width override , globalMonoidStackYaml :: !(First FilePath) -- ^ Override project stack.yaml } deriving (Show, Generic) instance Semigroup GlobalOptsMonoid where (<>) = mappenddefault instance Monoid GlobalOptsMonoid where mempty = memptydefault mappend = (<>) -- | Default logging level should be something useful but not crazy. defaultLogLevel :: LogLevel defaultLogLevel = LevelInfo readColorWhen :: ReadM ColorWhen readColorWhen = do s <- OA.readerAsk case s of "never" -> return ColorNever "always" -> return ColorAlways "auto" -> return ColorAuto _ -> OA.readerError "Expected values of color option are 'never', 'always', or 'auto'." -- | A superset of 'Config' adding information on how to build code. The reason -- for this breakdown is because we will need some of the information from -- 'Config' in order to determine the values here. -- -- These are the components which know nothing about local configuration. data BuildConfig = BuildConfig { bcConfig :: !Config , bcSnapshotDef :: !SnapshotDef -- ^ Build plan wanted for this build , bcGHCVariant :: !GHCVariant -- ^ The variant of GHC used to select a GHC bindist. , bcPackages :: ![PackageLocation Subdirs] -- ^ Local packages , bcDependencies :: ![PackageLocationIndex Subdirs] -- ^ Extra dependencies specified in configuration. -- -- These dependencies will not be installed to a shared location, and -- will override packages provided by the resolver. , bcExtraPackageDBs :: ![Path Abs Dir] -- ^ Extra package databases , bcStackYaml :: !(Path Abs File) -- ^ Location of the stack.yaml file. -- -- Note: if the STACK_YAML environment variable is used, this may be -- different from projectRootL "stack.yaml" -- -- FIXME MSS 2016-12-08: is the above comment still true? projectRootL -- is defined in terms of bcStackYaml , bcFlags :: !(Map PackageName (Map FlagName Bool)) -- ^ Per-package flag overrides , bcImplicitGlobal :: !Bool -- ^ Are we loading from the implicit global stack.yaml? This is useful -- for providing better error messages. } stackYamlL :: HasBuildConfig env => Lens' env (Path Abs File) stackYamlL = buildConfigL.lens bcStackYaml (\x y -> x { bcStackYaml = y }) -- | Directory containing the project's stack.yaml file projectRootL :: HasBuildConfig env => Getting r env (Path Abs Dir) projectRootL = stackYamlL.to parent -- | Configuration after the environment has been setup. data EnvConfig = EnvConfig {envConfigBuildConfig :: !BuildConfig ,envConfigCabalVersion :: !Version -- ^ This is the version of Cabal that stack will use to compile Setup.hs files -- in the build process. -- -- Note that this is not necessarily the same version as the one that stack -- depends on as a library and which is displayed when running -- @stack list-dependencies | grep Cabal@ in the stack project. ,envConfigCompilerVersion :: !(CompilerVersion 'CVActual) -- ^ The actual version of the compiler to be used, as opposed to -- 'wantedCompilerL', which provides the version specified by the -- build plan. ,envConfigCompilerBuild :: !CompilerBuild ,envConfigPackagesRef :: !(IORef (Maybe LocalPackages)) -- ^ Cache for 'getLocalPackages'. ,envConfigLoadedSnapshot :: !LoadedSnapshot -- ^ The fully resolved snapshot information. } data LocalPackages = LocalPackages { lpProject :: !(Map PackageName LocalPackageView) , lpDependencies :: !(Map PackageName (GenericPackageDescription, PackageLocationIndex FilePath)) } -- | A view of a local package needed for resolving components data LocalPackageView = LocalPackageView { lpvCabalFP :: !(Path Abs File) , lpvGPD :: !GenericPackageDescription , lpvLoc :: !(PackageLocation FilePath) } -- | Root directory for the given 'LocalPackageView' lpvRoot :: LocalPackageView -> Path Abs Dir lpvRoot = parent . lpvCabalFP -- | Package name for the given 'LocalPackageView lpvName :: LocalPackageView -> PackageName lpvName lpv = let PackageIdentifier name _version = fromCabalPackageIdentifier $ C.package $ C.packageDescription $ lpvGPD lpv in name -- | All components available in the given 'LocalPackageView' lpvComponents :: LocalPackageView -> Set NamedComponent lpvComponents lpv = Set.fromList $ concat [ maybe [] (const [CLib]) (C.condLibrary gpkg) , go CExe (map fst . C.condExecutables) , go CTest (map fst . C.condTestSuites) , go CBench (map fst . C.condBenchmarks) ] where gpkg = lpvGPD lpv go :: (T.Text -> NamedComponent) -> (C.GenericPackageDescription -> [C.UnqualComponentName]) -> [NamedComponent] go wrapper f = map (wrapper . T.pack . C.unUnqualComponentName) $ f gpkg -- | Version for the given 'LocalPackageView lpvVersion :: LocalPackageView -> Version lpvVersion lpv = let PackageIdentifier _name version = fromCabalPackageIdentifier $ C.package $ C.packageDescription $ lpvGPD lpv in version -- | Value returned by 'Stack.Config.loadConfig'. data LoadConfig = LoadConfig { lcConfig :: !Config -- ^ Top-level Stack configuration. , lcLoadBuildConfig :: !(Maybe (CompilerVersion 'CVWanted) -> IO BuildConfig) -- ^ Action to load the remaining 'BuildConfig'. , lcProjectRoot :: !(Maybe (Path Abs Dir)) -- ^ The project root directory, if in a project. } data PackageEntry = PackageEntry { peExtraDepMaybe :: !(Maybe TreatLikeExtraDep) , peLocation :: !(PackageLocation Subdirs) , peSubdirs :: !Subdirs } deriving Show -- | Should a package be treated just like an extra-dep? -- -- 'True' means, it will only be built as a dependency -- for others, and its test suite/benchmarks will not be run. -- -- Useful modifying an upstream package, see: -- https://github.com/commercialhaskell/stack/issues/219 -- https://github.com/commercialhaskell/stack/issues/386 type TreatLikeExtraDep = Bool instance FromJSON (WithJSONWarnings PackageEntry) where parseJSON (String t) = do WithJSONWarnings loc _ <- parseJSON $ String t return $ noJSONWarnings PackageEntry { peExtraDepMaybe = Nothing , peLocation = loc , peSubdirs = DefaultSubdirs } parseJSON v = withObjectWarnings "PackageEntry" (\o -> PackageEntry <$> o ..:? "extra-dep" <*> jsonSubWarnings (o ..: "location") <*> o ..:? "subdirs" ..!= DefaultSubdirs) v -- | A project is a collection of packages. We can have multiple stack.yaml -- files, but only one of them may contain project information. data Project = Project { projectUserMsg :: !(Maybe String) -- ^ A warning message to display to the user when the auto generated -- config may have issues. , projectPackages :: ![PackageLocation Subdirs] -- ^ Packages which are actually part of the project (as opposed -- to dependencies). -- -- /NOTE/ Stack has always allowed these packages to be any kind -- of package location, but in reality only @PLFilePath@ really -- makes sense. We could consider replacing @[PackageLocation]@ -- with @[FilePath]@ to properly enforce this idea, though it will -- slightly break backwards compatibility if someone really did -- want to treat such things as non-deps. , projectDependencies :: ![PackageLocationIndex Subdirs] -- ^ Dependencies defined within the stack.yaml file, to be -- applied on top of the snapshot. , projectFlags :: !(Map PackageName (Map FlagName Bool)) -- ^ Flags to be applied on top of the snapshot flags. , projectResolver :: !Resolver -- ^ How we resolve which @SnapshotDef@ to use , projectCompiler :: !(Maybe (CompilerVersion 'CVWanted)) -- ^ When specified, overrides which compiler to use , projectExtraPackageDBs :: ![FilePath] } deriving Show instance ToJSON Project where -- Expanding the constructor fully to ensure we don't miss any fields. toJSON (Project userMsg packages extraDeps flags resolver compiler extraPackageDBs) = object $ concat [ maybe [] (\cv -> ["compiler" .= cv]) compiler , maybe [] (\msg -> ["user-message" .= msg]) userMsg , if null extraPackageDBs then [] else ["extra-package-dbs" .= extraPackageDBs] , if null extraDeps then [] else ["extra-deps" .= extraDeps] , if Map.null flags then [] else ["flags" .= flags] , ["packages" .= packages] , ["resolver" .= resolver] ] -- An uninterpreted representation of configuration options. -- Configurations may be "cascaded" using mappend (left-biased). data ConfigMonoid = ConfigMonoid { configMonoidStackRoot :: !(First (Path Abs Dir)) -- ^ See: 'clStackRoot' , configMonoidWorkDir :: !(First (Path Rel Dir)) -- ^ See: 'configWorkDir'. , configMonoidBuildOpts :: !BuildOptsMonoid -- ^ build options. , configMonoidDockerOpts :: !DockerOptsMonoid -- ^ Docker options. , configMonoidNixOpts :: !NixOptsMonoid -- ^ Options for the execution environment (nix-shell or container) , configMonoidConnectionCount :: !(First Int) -- ^ See: 'configConnectionCount' , configMonoidHideTHLoading :: !(First Bool) -- ^ See: 'configHideTHLoading' , configMonoidLatestSnapshotUrl :: !(First Text) -- ^ Deprecated in favour of 'urlsMonoidLatestSnapshot' , configMonoidUrls :: !UrlsMonoid -- ^ See: 'configUrls , configMonoidPackageIndices :: !(First [PackageIndex]) -- ^ See: @picIndices@ , configMonoidSystemGHC :: !(First Bool) -- ^ See: 'configSystemGHC' ,configMonoidInstallGHC :: !(First Bool) -- ^ See: 'configInstallGHC' ,configMonoidSkipGHCCheck :: !(First Bool) -- ^ See: 'configSkipGHCCheck' ,configMonoidSkipMsys :: !(First Bool) -- ^ See: 'configSkipMsys' ,configMonoidCompilerCheck :: !(First VersionCheck) -- ^ See: 'configCompilerCheck' ,configMonoidRequireStackVersion :: !IntersectingVersionRange -- ^ See: 'configRequireStackVersion' ,configMonoidArch :: !(First String) -- ^ Used for overriding the platform ,configMonoidGHCVariant :: !(First GHCVariant) -- ^ Used for overriding the platform ,configMonoidGHCBuild :: !(First CompilerBuild) -- ^ Used for overriding the GHC build ,configMonoidJobs :: !(First Int) -- ^ See: 'configJobs' ,configMonoidExtraIncludeDirs :: !(Set FilePath) -- ^ See: 'configExtraIncludeDirs' ,configMonoidExtraLibDirs :: !(Set FilePath) -- ^ See: 'configExtraLibDirs' , configMonoidOverrideGccPath :: !(First (Path Abs File)) -- ^ Allow users to override the path to gcc ,configMonoidOverrideHpack :: !(First FilePath) -- ^ Use Hpack executable (overrides bundled Hpack) ,configMonoidConcurrentTests :: !(First Bool) -- ^ See: 'configConcurrentTests' ,configMonoidLocalBinPath :: !(First FilePath) -- ^ Used to override the binary installation dir ,configMonoidImageOpts :: !ImageOptsMonoid -- ^ Image creation options. ,configMonoidTemplateParameters :: !(Map Text Text) -- ^ Template parameters. ,configMonoidScmInit :: !(First SCM) -- ^ Initialize SCM (e.g. git init) when making new projects? ,configMonoidGhcOptionsByName :: !(MonoidMap PackageName (Monoid.Dual [Text])) -- ^ See 'configGhcOptionsByName'. Uses 'Monoid.Dual' so that -- options from the configs on the right come first, so that they -- can be overridden. ,configMonoidGhcOptionsByCat :: !(MonoidMap ApplyGhcOptions (Monoid.Dual [Text])) -- ^ See 'configGhcOptionsAll'. Uses 'Monoid.Dual' so that options -- from the configs on the right come first, so that they can be -- overridden. ,configMonoidExtraPath :: ![Path Abs Dir] -- ^ Additional paths to search for executables in ,configMonoidSetupInfoLocations :: ![SetupInfoLocation] -- ^ Additional setup info (inline or remote) to use for installing tools ,configMonoidLocalProgramsBase :: !(First (Path Abs Dir)) -- ^ Override the default local programs dir, where e.g. GHC is installed. ,configMonoidPvpBounds :: !(First PvpBounds) -- ^ See 'configPvpBounds' ,configMonoidModifyCodePage :: !(First Bool) -- ^ See 'configModifyCodePage' ,configMonoidExplicitSetupDeps :: !(Map (Maybe PackageName) Bool) -- ^ See 'configExplicitSetupDeps' ,configMonoidRebuildGhcOptions :: !(First Bool) -- ^ See 'configMonoidRebuildGhcOptions' ,configMonoidApplyGhcOptions :: !(First ApplyGhcOptions) -- ^ See 'configApplyGhcOptions' ,configMonoidAllowNewer :: !(First Bool) -- ^ See 'configMonoidAllowNewer' ,configMonoidDefaultTemplate :: !(First TemplateName) -- ^ The default template to use when none is specified. -- (If Nothing, the default default is used.) , configMonoidAllowDifferentUser :: !(First Bool) -- ^ Allow users other than the stack root owner to use the stack -- installation. , configMonoidDumpLogs :: !(First DumpLogs) -- ^ See 'configDumpLogs' , configMonoidSaveHackageCreds :: !(First Bool) -- ^ See 'configSaveHackageCreds' , configMonoidHackageBaseUrl :: !(First Text) -- ^ See 'configHackageBaseUrl' , configMonoidIgnoreRevisionMismatch :: !(First Bool) -- ^ See 'configIgnoreRevisionMismatch' } deriving (Show, Generic) instance Semigroup ConfigMonoid where (<>) = mappenddefault instance Monoid ConfigMonoid where mempty = memptydefault mappend = (<>) parseConfigMonoid :: Path Abs Dir -> Value -> Yaml.Parser (WithJSONWarnings ConfigMonoid) parseConfigMonoid = withObjectWarnings "ConfigMonoid" . parseConfigMonoidObject -- | Parse a partial configuration. Used both to parse both a standalone config -- file and a project file, so that a sub-parser is not required, which would interfere with -- warnings for missing fields. parseConfigMonoidObject :: Path Abs Dir -> Object -> WarningParser ConfigMonoid parseConfigMonoidObject rootDir obj = do -- Parsing 'stackRoot' from 'stackRoot'/config.yaml would be nonsensical let configMonoidStackRoot = First Nothing configMonoidWorkDir <- First <$> obj ..:? configMonoidWorkDirName configMonoidBuildOpts <- jsonSubWarnings (obj ..:? configMonoidBuildOptsName ..!= mempty) configMonoidDockerOpts <- jsonSubWarnings (obj ..:? configMonoidDockerOptsName ..!= mempty) configMonoidNixOpts <- jsonSubWarnings (obj ..:? configMonoidNixOptsName ..!= mempty) configMonoidConnectionCount <- First <$> obj ..:? configMonoidConnectionCountName configMonoidHideTHLoading <- First <$> obj ..:? configMonoidHideTHLoadingName configMonoidLatestSnapshotUrl <- First <$> obj ..:? configMonoidLatestSnapshotUrlName configMonoidUrls <- jsonSubWarnings (obj ..:? configMonoidUrlsName ..!= mempty) configMonoidPackageIndices <- First <$> jsonSubWarningsTT (obj ..:? configMonoidPackageIndicesName) configMonoidSystemGHC <- First <$> obj ..:? configMonoidSystemGHCName configMonoidInstallGHC <- First <$> obj ..:? configMonoidInstallGHCName configMonoidSkipGHCCheck <- First <$> obj ..:? configMonoidSkipGHCCheckName configMonoidSkipMsys <- First <$> obj ..:? configMonoidSkipMsysName configMonoidRequireStackVersion <- IntersectingVersionRange . unVersionRangeJSON <$> ( obj ..:? configMonoidRequireStackVersionName ..!= VersionRangeJSON anyVersion) configMonoidArch <- First <$> obj ..:? configMonoidArchName configMonoidGHCVariant <- First <$> obj ..:? configMonoidGHCVariantName configMonoidGHCBuild <- First <$> obj ..:? configMonoidGHCBuildName configMonoidJobs <- First <$> obj ..:? configMonoidJobsName configMonoidExtraIncludeDirs <- fmap (Set.map (toFilePath rootDir FilePath.)) $ obj ..:? configMonoidExtraIncludeDirsName ..!= Set.empty configMonoidExtraLibDirs <- fmap (Set.map (toFilePath rootDir FilePath.)) $ obj ..:? configMonoidExtraLibDirsName ..!= Set.empty configMonoidOverrideGccPath <- First <$> obj ..:? configMonoidOverrideGccPathName configMonoidOverrideHpack <- First <$> obj ..:? configMonoidOverrideHpackName configMonoidConcurrentTests <- First <$> obj ..:? configMonoidConcurrentTestsName configMonoidLocalBinPath <- First <$> obj ..:? configMonoidLocalBinPathName configMonoidImageOpts <- jsonSubWarnings (obj ..:? configMonoidImageOptsName ..!= mempty) templates <- obj ..:? "templates" (configMonoidScmInit,configMonoidTemplateParameters) <- case templates of Nothing -> return (First Nothing,M.empty) Just tobj -> do scmInit <- tobj ..:? configMonoidScmInitName params <- tobj ..:? configMonoidTemplateParametersName return (First scmInit,fromMaybe M.empty params) configMonoidCompilerCheck <- First <$> obj ..:? configMonoidCompilerCheckName options <- Map.map unGhcOptions <$> obj ..:? configMonoidGhcOptionsName ..!= mempty optionsEverything <- case (Map.lookup GOKOldEverything options, Map.lookup GOKEverything options) of (Just _, Just _) -> fail "Cannot specify both `*` and `$everything` GHC options" (Nothing, Just x) -> return x (Just x, Nothing) -> do tell "The `*` ghc-options key is not recommended. Consider using $locals, or if really needed, $everything" return x (Nothing, Nothing) -> return [] let configMonoidGhcOptionsByCat = coerce $ Map.fromList [ (AGOEverything, optionsEverything) , (AGOLocals, Map.findWithDefault [] GOKLocals options) , (AGOTargets, Map.findWithDefault [] GOKTargets options) ] configMonoidGhcOptionsByName = coerce $ Map.fromList [(name, opts) | (GOKPackage name, opts) <- Map.toList options] configMonoidExtraPath <- obj ..:? configMonoidExtraPathName ..!= [] configMonoidSetupInfoLocations <- maybeToList <$> jsonSubWarningsT (obj ..:? configMonoidSetupInfoLocationsName) configMonoidLocalProgramsBase <- First <$> obj ..:? configMonoidLocalProgramsBaseName configMonoidPvpBounds <- First <$> obj ..:? configMonoidPvpBoundsName configMonoidModifyCodePage <- First <$> obj ..:? configMonoidModifyCodePageName configMonoidExplicitSetupDeps <- (obj ..:? configMonoidExplicitSetupDepsName ..!= mempty) >>= fmap Map.fromList . mapM handleExplicitSetupDep . Map.toList configMonoidRebuildGhcOptions <- First <$> obj ..:? configMonoidRebuildGhcOptionsName configMonoidApplyGhcOptions <- First <$> obj ..:? configMonoidApplyGhcOptionsName configMonoidAllowNewer <- First <$> obj ..:? configMonoidAllowNewerName configMonoidDefaultTemplate <- First <$> obj ..:? configMonoidDefaultTemplateName configMonoidAllowDifferentUser <- First <$> obj ..:? configMonoidAllowDifferentUserName configMonoidDumpLogs <- First <$> obj ..:? configMonoidDumpLogsName configMonoidSaveHackageCreds <- First <$> obj ..:? configMonoidSaveHackageCredsName configMonoidHackageBaseUrl <- First <$> obj ..:? configMonoidHackageBaseUrlName configMonoidIgnoreRevisionMismatch <- First <$> obj ..:? configMonoidIgnoreRevisionMismatchName return ConfigMonoid {..} where handleExplicitSetupDep :: Monad m => (Text, Bool) -> m (Maybe PackageName, Bool) handleExplicitSetupDep (name', b) = do name <- if name' == "*" then return Nothing else case parsePackageNameFromString $ T.unpack name' of Left e -> fail $ show e Right x -> return $ Just x return (name, b) configMonoidWorkDirName :: Text configMonoidWorkDirName = "work-dir" configMonoidBuildOptsName :: Text configMonoidBuildOptsName = "build" configMonoidDockerOptsName :: Text configMonoidDockerOptsName = "docker" configMonoidNixOptsName :: Text configMonoidNixOptsName = "nix" configMonoidConnectionCountName :: Text configMonoidConnectionCountName = "connection-count" configMonoidHideTHLoadingName :: Text configMonoidHideTHLoadingName = "hide-th-loading" configMonoidLatestSnapshotUrlName :: Text configMonoidLatestSnapshotUrlName = "latest-snapshot-url" configMonoidUrlsName :: Text configMonoidUrlsName = "urls" configMonoidPackageIndicesName :: Text configMonoidPackageIndicesName = "package-indices" configMonoidSystemGHCName :: Text configMonoidSystemGHCName = "system-ghc" configMonoidInstallGHCName :: Text configMonoidInstallGHCName = "install-ghc" configMonoidSkipGHCCheckName :: Text configMonoidSkipGHCCheckName = "skip-ghc-check" configMonoidSkipMsysName :: Text configMonoidSkipMsysName = "skip-msys" configMonoidRequireStackVersionName :: Text configMonoidRequireStackVersionName = "require-stack-version" configMonoidArchName :: Text configMonoidArchName = "arch" configMonoidGHCVariantName :: Text configMonoidGHCVariantName = "ghc-variant" configMonoidGHCBuildName :: Text configMonoidGHCBuildName = "ghc-build" configMonoidJobsName :: Text configMonoidJobsName = "jobs" configMonoidExtraIncludeDirsName :: Text configMonoidExtraIncludeDirsName = "extra-include-dirs" configMonoidExtraLibDirsName :: Text configMonoidExtraLibDirsName = "extra-lib-dirs" configMonoidOverrideGccPathName :: Text configMonoidOverrideGccPathName = "with-gcc" configMonoidOverrideHpackName :: Text configMonoidOverrideHpackName = "with-hpack" configMonoidConcurrentTestsName :: Text configMonoidConcurrentTestsName = "concurrent-tests" configMonoidLocalBinPathName :: Text configMonoidLocalBinPathName = "local-bin-path" configMonoidImageOptsName :: Text configMonoidImageOptsName = "image" configMonoidScmInitName :: Text configMonoidScmInitName = "scm-init" configMonoidTemplateParametersName :: Text configMonoidTemplateParametersName = "params" configMonoidCompilerCheckName :: Text configMonoidCompilerCheckName = "compiler-check" configMonoidGhcOptionsName :: Text configMonoidGhcOptionsName = "ghc-options" configMonoidExtraPathName :: Text configMonoidExtraPathName = "extra-path" configMonoidSetupInfoLocationsName :: Text configMonoidSetupInfoLocationsName = "setup-info" configMonoidLocalProgramsBaseName :: Text configMonoidLocalProgramsBaseName = "local-programs-path" configMonoidPvpBoundsName :: Text configMonoidPvpBoundsName = "pvp-bounds" configMonoidModifyCodePageName :: Text configMonoidModifyCodePageName = "modify-code-page" configMonoidExplicitSetupDepsName :: Text configMonoidExplicitSetupDepsName = "explicit-setup-deps" configMonoidRebuildGhcOptionsName :: Text configMonoidRebuildGhcOptionsName = "rebuild-ghc-options" configMonoidApplyGhcOptionsName :: Text configMonoidApplyGhcOptionsName = "apply-ghc-options" configMonoidAllowNewerName :: Text configMonoidAllowNewerName = "allow-newer" configMonoidDefaultTemplateName :: Text configMonoidDefaultTemplateName = "default-template" configMonoidAllowDifferentUserName :: Text configMonoidAllowDifferentUserName = "allow-different-user" configMonoidDumpLogsName :: Text configMonoidDumpLogsName = "dump-logs" configMonoidSaveHackageCredsName :: Text configMonoidSaveHackageCredsName = "save-hackage-creds" configMonoidHackageBaseUrlName :: Text configMonoidHackageBaseUrlName = "hackage-base-url" configMonoidIgnoreRevisionMismatchName :: Text configMonoidIgnoreRevisionMismatchName = "ignore-revision-mismatch" data ConfigException = ParseConfigFileException (Path Abs File) ParseException | ParseCustomSnapshotException Text ParseException | NoProjectConfigFound (Path Abs Dir) (Maybe Text) | UnexpectedArchiveContents [Path Abs Dir] [Path Abs File] | UnableToExtractArchive Text (Path Abs File) | BadStackVersionException VersionRange | NoMatchingSnapshot WhichSolverCmd (NonEmpty SnapName) | ResolverMismatch WhichSolverCmd !Text String -- Text == resolver name, sdName | ResolverPartial WhichSolverCmd !Text String -- Text == resolver name, sdName | NoSuchDirectory FilePath | ParseGHCVariantException String | BadStackRoot (Path Abs Dir) | Won'tCreateStackRootInDirectoryOwnedByDifferentUser (Path Abs Dir) (Path Abs Dir) -- ^ @$STACK_ROOT@, parent dir | UserDoesn'tOwnDirectory (Path Abs Dir) | FailedToCloneRepo String | ManualGHCVariantSettingsAreIncompatibleWithSystemGHC | NixRequiresSystemGhc | NoResolverWhenUsingNoLocalConfig | InvalidResolverForNoLocalConfig String | DuplicateLocalPackageNames ![(PackageName, [PackageLocationIndex FilePath])] deriving Typeable instance Show ConfigException where show (ParseConfigFileException configFile exception) = concat [ "Could not parse '" , toFilePath configFile , "':\n" , Yaml.prettyPrintParseException exception , "\nSee http://docs.haskellstack.org/en/stable/yaml_configuration/" ] show (ParseCustomSnapshotException url exception) = concat [ "Could not parse '" , T.unpack url , "':\n" , Yaml.prettyPrintParseException exception -- FIXME: Link to docs about custom snapshots -- , "\nSee http://docs.haskellstack.org/en/stable/yaml_configuration/" ] show (NoProjectConfigFound dir mcmd) = concat [ "Unable to find a stack.yaml file in the current directory (" , toFilePath dir , ") or its ancestors" , case mcmd of Nothing -> "" Just cmd -> "\nRecommended action: stack " ++ T.unpack cmd ] show (UnexpectedArchiveContents dirs files) = concat [ "When unpacking an archive specified in your stack.yaml file, " , "did not find expected contents. Expected: a single directory. Found: " , show ( map (toFilePath . dirname) dirs , map (toFilePath . filename) files ) ] show (UnableToExtractArchive url file) = concat [ "Archive extraction failed. Tarballs and zip archives are supported, couldn't handle the following URL, " , T.unpack url, " downloaded to the file ", toFilePath $ filename file ] show (BadStackVersionException requiredRange) = concat [ "The version of stack you are using (" , show (fromCabalVersion (mkVersion' Meta.version)) , ") is outside the required\n" ,"version range specified in stack.yaml (" , T.unpack (versionRangeText requiredRange) , ")." ] show (NoMatchingSnapshot whichCmd names) = concat [ "None of the following snapshots provides a compiler matching " , "your package(s):\n" , unlines $ map (\name -> " - " <> T.unpack (renderSnapName name)) (NonEmpty.toList names) , showOptions whichCmd Don'tSuggestSolver ] show (ResolverMismatch whichCmd resolver errDesc) = concat [ "Resolver '" , T.unpack resolver , "' does not have a matching compiler to build some or all of your " , "package(s).\n" , errDesc , showOptions whichCmd Don'tSuggestSolver ] show (ResolverPartial whichCmd resolver errDesc) = concat [ "Resolver '" , T.unpack resolver , "' does not have all the packages to match your requirements.\n" , unlines $ fmap (" " <>) (lines errDesc) , showOptions whichCmd (case whichCmd of IsSolverCmd -> Don'tSuggestSolver _ -> SuggestSolver) ] show (NoSuchDirectory dir) = "No directory could be located matching the supplied path: " ++ dir show (ParseGHCVariantException v) = "Invalid ghc-variant value: " ++ v show (BadStackRoot stackRoot) = concat [ "Invalid stack root: '" , toFilePath stackRoot , "'. Please provide a valid absolute path." ] show (Won'tCreateStackRootInDirectoryOwnedByDifferentUser envStackRoot parentDir) = concat [ "Preventing creation of stack root '" , toFilePath envStackRoot , "'. Parent directory '" , toFilePath parentDir , "' is owned by someone else." ] show (UserDoesn'tOwnDirectory dir) = concat [ "You are not the owner of '" , toFilePath dir , "'. Aborting to protect file permissions." , "\nRetry with '--" , T.unpack configMonoidAllowDifferentUserName , "' to disable this precaution." ] show (FailedToCloneRepo commandName) = concat [ "Failed to use " , commandName , " to clone the repo. Please ensure that " , commandName , " is installed and available to stack on your PATH environment variable." ] show ManualGHCVariantSettingsAreIncompatibleWithSystemGHC = T.unpack $ T.concat [ "stack can only control the " , configMonoidGHCVariantName , " of its own GHC installations. Please use '--no-" , configMonoidSystemGHCName , "'." ] show NixRequiresSystemGhc = T.unpack $ T.concat [ "stack's Nix integration is incompatible with '--no-system-ghc'. " , "Please use '--" , configMonoidSystemGHCName , "' or disable the Nix integration." ] show NoResolverWhenUsingNoLocalConfig = "When using the script command, you must provide a resolver argument" show (InvalidResolverForNoLocalConfig ar) = "The script command requires a specific resolver, you provided " ++ ar show (DuplicateLocalPackageNames pairs) = concat $ "The same package name is used in multiple local packages\n" : map go pairs where go (name, dirs) = unlines $ "" : (packageNameString name ++ " used in:") : map goLoc dirs goLoc loc = "- " ++ show loc instance Exception ConfigException showOptions :: WhichSolverCmd -> SuggestSolver -> String showOptions whichCmd suggestSolver = unlines $ "\nThis may be resolved by:" : options where options = (case suggestSolver of SuggestSolver -> [useSolver] Don'tSuggestSolver -> []) ++ (case whichCmd of IsSolverCmd -> [useResolver] IsInitCmd -> both IsNewCmd -> both) both = [omitPackages, useResolver] useSolver = " - Using '--solver' to ask cabal-install to generate extra-deps, atop the chosen snapshot." omitPackages = " - Using '--omit-packages to exclude mismatching package(s)." useResolver = " - Using '--resolver' to specify a matching snapshot/resolver" data WhichSolverCmd = IsInitCmd | IsSolverCmd | IsNewCmd data SuggestSolver = SuggestSolver | Don'tSuggestSolver -- | Get the URL to request the information on the latest snapshots askLatestSnapshotUrl :: (MonadReader env m, HasConfig env) => m Text askLatestSnapshotUrl = view $ configL.to configUrls.to urlsLatestSnapshot -- | @".stack-work"@ workDirL :: HasConfig env => Lens' env (Path Rel Dir) workDirL = configL.lens configWorkDir (\x y -> x { configWorkDir = y }) -- | Per-project work dir getProjectWorkDir :: (HasBuildConfig env, MonadReader env m) => m (Path Abs Dir) getProjectWorkDir = do root <- view projectRootL workDir <- view workDirL return (root workDir) -- | File containing the installed cache, see "Stack.PackageDump" configInstalledCache :: (HasBuildConfig env, MonadReader env m) => m (Path Abs File) configInstalledCache = liftM ( $(mkRelFile "installed-cache.bin")) getProjectWorkDir -- | Relative directory for the platform identifier platformOnlyRelDir :: (MonadReader env m, HasPlatform env, MonadThrow m) => m (Path Rel Dir) platformOnlyRelDir = do platform <- view platformL platformVariant <- view platformVariantL parseRelDir (Distribution.Text.display platform ++ platformVariantSuffix platformVariant) -- | Directory containing snapshots snapshotsDir :: (MonadReader env m, HasEnvConfig env, MonadThrow m) => m (Path Abs Dir) snapshotsDir = do root <- view stackRootL platform <- platformGhcRelDir return $ root $(mkRelDir "snapshots") platform -- | Installation root for dependencies installationRootDeps :: (MonadThrow m, MonadReader env m, HasEnvConfig env) => m (Path Abs Dir) installationRootDeps = do root <- view stackRootL -- TODO: also useShaPathOnWindows here, once #1173 is resolved. psc <- platformSnapAndCompilerRel return $ root $(mkRelDir "snapshots") psc -- | Installation root for locals installationRootLocal :: (MonadThrow m, MonadReader env m, HasEnvConfig env) => m (Path Abs Dir) installationRootLocal = do workDir <- getProjectWorkDir psc <- useShaPathOnWindows =<< platformSnapAndCompilerRel return $ workDir $(mkRelDir "install") psc -- | Installation root for compiler tools bindirCompilerTools :: (MonadThrow m, MonadReader env m, HasEnvConfig env) => m (Path Abs Dir) bindirCompilerTools = do config <- view configL platform <- platformGhcRelDir compilerVersion <- envConfigCompilerVersion <$> view envConfigL compiler <- parseRelDir $ compilerVersionString compilerVersion return $ view stackRootL config $(mkRelDir "compiler-tools") platform compiler bindirSuffix -- | Hoogle directory. hoogleRoot :: (MonadThrow m, MonadReader env m, HasEnvConfig env) => m (Path Abs Dir) hoogleRoot = do workDir <- getProjectWorkDir psc <- useShaPathOnWindows =<< platformSnapAndCompilerRel return $ workDir $(mkRelDir "hoogle") psc -- | Get the hoogle database path. hoogleDatabasePath :: (MonadThrow m, MonadReader env m, HasEnvConfig env) => m (Path Abs File) hoogleDatabasePath = do dir <- hoogleRoot return (dir $(mkRelFile "database.hoo")) -- | Path for platform followed by snapshot name followed by compiler -- name. platformSnapAndCompilerRel :: (MonadReader env m, HasEnvConfig env, MonadThrow m) => m (Path Rel Dir) platformSnapAndCompilerRel = do sd <- view snapshotDefL platform <- platformGhcRelDir name <- parseRelDir $ sdRawPathName sd ghc <- compilerVersionDir useShaPathOnWindows (platform name ghc) -- | Relative directory for the platform and GHC identifier platformGhcRelDir :: (MonadReader env m, HasEnvConfig env, MonadThrow m) => m (Path Rel Dir) platformGhcRelDir = do ec <- view envConfigL verOnly <- platformGhcVerOnlyRelDirStr parseRelDir (mconcat [ verOnly , compilerBuildSuffix (envConfigCompilerBuild ec)]) -- | Relative directory for the platform and GHC identifier without GHC bindist build platformGhcVerOnlyRelDir :: (MonadReader env m, HasPlatform env, HasGHCVariant env, MonadThrow m) => m (Path Rel Dir) platformGhcVerOnlyRelDir = parseRelDir =<< platformGhcVerOnlyRelDirStr -- | Relative directory for the platform and GHC identifier without GHC bindist build -- (before parsing into a Path) platformGhcVerOnlyRelDirStr :: (MonadReader env m, HasPlatform env, HasGHCVariant env) => m FilePath platformGhcVerOnlyRelDirStr = do platform <- view platformL platformVariant <- view platformVariantL ghcVariant <- view ghcVariantL return $ mconcat [ Distribution.Text.display platform , platformVariantSuffix platformVariant , ghcVariantSuffix ghcVariant ] -- | This is an attempt to shorten stack paths on Windows to decrease our -- chances of hitting 260 symbol path limit. The idea is to calculate -- SHA1 hash of the path used on other architectures, encode with base -- 16 and take first 8 symbols of it. useShaPathOnWindows :: MonadThrow m => Path Rel Dir -> m (Path Rel Dir) useShaPathOnWindows = #ifdef mingw32_HOST_OS shaPath #else return #endif shaPath :: (IsPath Rel t, MonadThrow m) => Path Rel t -> m (Path Rel t) shaPath = shaPathForBytes . encodeUtf8 . T.pack . toFilePath shaPathForBytes :: (IsPath Rel t, MonadThrow m) => ByteString -> m (Path Rel t) shaPathForBytes = parsePath . S8.unpack . S8.take 8 . Mem.convertToBase Mem.Base16 . hashWith SHA1 -- TODO: Move something like this into the path package. Consider -- subsuming path-io's 'AnyPath'? class IsPath b t where parsePath :: MonadThrow m => FilePath -> m (Path b t) instance IsPath Abs Dir where parsePath = parseAbsDir instance IsPath Rel Dir where parsePath = parseRelDir instance IsPath Abs File where parsePath = parseAbsFile instance IsPath Rel File where parsePath = parseRelFile compilerVersionDir :: (MonadThrow m, MonadReader env m, HasEnvConfig env) => m (Path Rel Dir) compilerVersionDir = do compilerVersion <- view actualCompilerVersionL parseRelDir $ case compilerVersion of GhcVersion version -> versionString version GhcjsVersion {} -> compilerVersionString compilerVersion -- | Package database for installing dependencies into packageDatabaseDeps :: (MonadThrow m, MonadReader env m, HasEnvConfig env) => m (Path Abs Dir) packageDatabaseDeps = do root <- installationRootDeps return $ root $(mkRelDir "pkgdb") -- | Package database for installing local packages into packageDatabaseLocal :: (MonadThrow m, MonadReader env m, HasEnvConfig env) => m (Path Abs Dir) packageDatabaseLocal = do root <- installationRootLocal return $ root $(mkRelDir "pkgdb") -- | Extra package databases packageDatabaseExtra :: (MonadReader env m, HasEnvConfig env) => m [Path Abs Dir] packageDatabaseExtra = view $ buildConfigL.to bcExtraPackageDBs -- | Directory for holding flag cache information flagCacheLocal :: (MonadThrow m, MonadReader env m, HasEnvConfig env) => m (Path Abs Dir) flagCacheLocal = do root <- installationRootLocal return $ root $(mkRelDir "flag-cache") -- | Where to store 'LoadedSnapshot' caches configLoadedSnapshotCache :: (MonadThrow m, MonadReader env m, HasConfig env, HasGHCVariant env) => SnapshotDef -> GlobalInfoSource -> m (Path Abs File) configLoadedSnapshotCache sd gis = do root <- view stackRootL platform <- platformGhcVerOnlyRelDir file <- parseRelFile $ sdRawPathName sd ++ ".cache" gis' <- parseRelDir $ case gis of GISSnapshotHints -> "__snapshot_hints__" GISCompiler cv -> compilerVersionString cv -- Yes, cached plans differ based on platform return (root $(mkRelDir "loaded-snapshot-cache") platform gis' file) -- | Where do we get information on global packages for loading up a -- 'LoadedSnapshot'? data GlobalInfoSource = GISSnapshotHints -- ^ Accept the hints in the snapshot definition | GISCompiler (CompilerVersion 'CVActual) -- ^ Look up the actual information in the installed compiler -- | Suffix applied to an installation root to get the bin dir bindirSuffix :: Path Rel Dir bindirSuffix = $(mkRelDir "bin") -- | Suffix applied to an installation root to get the doc dir docDirSuffix :: Path Rel Dir docDirSuffix = $(mkRelDir "doc") -- | Where HPC reports and tix files get stored. hpcReportDir :: (MonadThrow m, MonadReader env m, HasEnvConfig env) => m (Path Abs Dir) hpcReportDir = do root <- installationRootLocal return $ root $(mkRelDir "hpc") -- | Get the extra bin directories (for the PATH). Puts more local first -- -- Bool indicates whether or not to include the locals extraBinDirs :: (MonadThrow m, MonadReader env m, HasEnvConfig env) => m (Bool -> [Path Abs Dir]) extraBinDirs = do deps <- installationRootDeps local' <- installationRootLocal tools <- bindirCompilerTools return $ \locals -> if locals then [local' bindirSuffix, deps bindirSuffix, tools] else [deps bindirSuffix, tools] minimalEnvSettings :: EnvSettings minimalEnvSettings = EnvSettings { esIncludeLocals = False , esIncludeGhcPackagePath = False , esStackExe = False , esLocaleUtf8 = False , esKeepGhcRts = False } -- | Default @EnvSettings@ which includes locals and GHC_PACKAGE_PATH. -- -- Note that this also passes through the GHCRTS environment variable. -- See https://github.com/commercialhaskell/stack/issues/3444 defaultEnvSettings :: EnvSettings defaultEnvSettings = EnvSettings { esIncludeLocals = True , esIncludeGhcPackagePath = True , esStackExe = True , esLocaleUtf8 = False , esKeepGhcRts = True } -- | Environment settings which do not embellish the environment -- -- Note that this also passes through the GHCRTS environment variable. -- See https://github.com/commercialhaskell/stack/issues/3444 plainEnvSettings :: EnvSettings plainEnvSettings = EnvSettings { esIncludeLocals = False , esIncludeGhcPackagePath = False , esStackExe = False , esLocaleUtf8 = False , esKeepGhcRts = True } -- | Get the path for the given compiler ignoring any local binaries. -- -- https://github.com/commercialhaskell/stack/issues/1052 getCompilerPath :: (MonadIO m, MonadThrow m, MonadReader env m, HasConfig env) => WhichCompiler -> m (Path Abs File) getCompilerPath wc = do config' <- view configL eoWithoutLocals <- liftIO $ configProcessContextSettings config' minimalEnvSettings { esLocaleUtf8 = True } eres <- runRIO eoWithoutLocals $ findExecutable $ compilerExeName wc case eres of Left e -> throwM e Right x -> parseAbsFile x data ProjectAndConfigMonoid = ProjectAndConfigMonoid !Project !ConfigMonoid parseProjectAndConfigMonoid :: Path Abs Dir -> Value -> Yaml.Parser (WithJSONWarnings ProjectAndConfigMonoid) parseProjectAndConfigMonoid rootDir = withObjectWarnings "ProjectAndConfigMonoid" $ \o -> do dirs <- jsonSubWarningsTT (o ..:? "packages") ..!= [packageEntryCurrDir] extraDeps <- jsonSubWarningsTT (o ..:? "extra-deps") ..!= [] flags <- o ..:? "flags" ..!= mempty -- Convert the packages/extra-deps/flags approach we use in -- the stack.yaml into the internal representation. let (packages, deps) = convert dirs extraDeps resolver <- (o ..: "resolver") >>= either (fail . show) return . parseCustomLocation (Just rootDir) compiler <- o ..:? "compiler" msg <- o ..:? "user-message" config <- parseConfigMonoidObject rootDir o extraPackageDBs <- o ..:? "extra-package-dbs" ..!= [] let project = Project { projectUserMsg = msg , projectResolver = resolver , projectCompiler = compiler , projectExtraPackageDBs = extraPackageDBs , projectPackages = packages , projectDependencies = deps , projectFlags = flags } return $ ProjectAndConfigMonoid project config where convert :: [PackageEntry] -> [PackageLocationIndex Subdirs] -- extra-deps -> ( [PackageLocation Subdirs] -- project , [PackageLocationIndex Subdirs] -- dependencies ) convert entries extraDeps = partitionEithers $ concatMap goEntry entries ++ map Right extraDeps where goEntry :: PackageEntry -> [Either (PackageLocation Subdirs) (PackageLocationIndex Subdirs)] goEntry (PackageEntry Nothing pl@(PLFilePath _) subdirs) = goEntry' False pl subdirs goEntry (PackageEntry Nothing pl _) = fail $ concat [ "Refusing to implicitly treat package location as an extra-dep:\n" , show pl , "\nRecommendation: either move to 'extra-deps' or set 'extra-dep: true'." ] goEntry (PackageEntry (Just extraDep) pl subdirs) = goEntry' extraDep pl subdirs goEntry' :: Bool -- ^ extra dep? -> PackageLocation Subdirs -> Subdirs -> [Either (PackageLocation Subdirs) (PackageLocationIndex Subdirs)] goEntry' extraDep pl subdirs = map (if extraDep then Right . PLOther else Left) (addSubdirs pl subdirs) combineSubdirs :: [FilePath] -> Subdirs -> Subdirs combineSubdirs paths DefaultSubdirs = ExplicitSubdirs paths -- this could be considered an error condition, but we'll -- just try and make it work combineSubdirs paths (ExplicitSubdirs paths') = ExplicitSubdirs (paths ++ paths') -- We do the toList/fromList bit as an efficient nub, and -- to avoid having duplicate subdir names (especially for -- the "." case, where parsing gets wonky). addSubdirs :: PackageLocation Subdirs -> Subdirs -> [PackageLocation Subdirs] addSubdirs pl DefaultSubdirs = [pl] addSubdirs (PLRepo repo) (ExplicitSubdirs subdirs) = [PLRepo repo { repoSubdirs = combineSubdirs subdirs $ repoSubdirs repo }] addSubdirs (PLArchive arch) (ExplicitSubdirs subdirs) = [PLArchive arch { archiveSubdirs = combineSubdirs subdirs $ archiveSubdirs arch }] addSubdirs (PLFilePath fp) (ExplicitSubdirs subdirs) = map (\subdir -> PLFilePath $ fp FilePath. subdir) subdirs -- | A PackageEntry for the current directory, used as a default packageEntryCurrDir :: PackageEntry packageEntryCurrDir = PackageEntry { peExtraDepMaybe = Nothing , peLocation = PLFilePath "." , peSubdirs = DefaultSubdirs } -- | A software control system. data SCM = Git deriving (Show) instance FromJSON SCM where parseJSON v = do s <- parseJSON v case s of "git" -> return Git _ -> fail ("Unknown or unsupported SCM: " <> s) instance ToJSON SCM where toJSON Git = toJSON ("git" :: Text) -- | A variant of the platform, used to differentiate Docker builds from host data PlatformVariant = PlatformVariantNone | PlatformVariant String -- | Render a platform variant to a String suffix. platformVariantSuffix :: PlatformVariant -> String platformVariantSuffix PlatformVariantNone = "" platformVariantSuffix (PlatformVariant v) = "-" ++ v -- | Specialized bariant of GHC (e.g. libgmp4 or integer-simple) data GHCVariant = GHCStandard -- ^ Standard bindist | GHCIntegerSimple -- ^ Bindist that uses integer-simple | GHCCustom String -- ^ Other bindists deriving (Show) instance FromJSON GHCVariant where -- Strange structuring is to give consistent error messages parseJSON = withText "GHCVariant" (either (fail . show) return . parseGHCVariant . T.unpack) -- | Render a GHC variant to a String. ghcVariantName :: GHCVariant -> String ghcVariantName GHCStandard = "standard" ghcVariantName GHCIntegerSimple = "integersimple" ghcVariantName (GHCCustom name) = "custom-" ++ name -- | Render a GHC variant to a String suffix. ghcVariantSuffix :: GHCVariant -> String ghcVariantSuffix GHCStandard = "" ghcVariantSuffix v = "-" ++ ghcVariantName v -- | Parse GHC variant from a String. parseGHCVariant :: (MonadThrow m) => String -> m GHCVariant parseGHCVariant s = case stripPrefix "custom-" s of Just name -> return (GHCCustom name) Nothing | s == "" -> return GHCStandard | s == "standard" -> return GHCStandard | s == "integersimple" -> return GHCIntegerSimple | otherwise -> return (GHCCustom s) -- | Build of the compiler distribution (e.g. standard, gmp4, tinfo6) -- | Information for a file to download. data DownloadInfo = DownloadInfo { downloadInfoUrl :: Text -- ^ URL or absolute file path , downloadInfoContentLength :: Maybe Int , downloadInfoSha1 :: Maybe ByteString , downloadInfoSha256 :: Maybe ByteString } deriving (Show) instance FromJSON (WithJSONWarnings DownloadInfo) where parseJSON = withObjectWarnings "DownloadInfo" parseDownloadInfoFromObject -- | Parse JSON in existing object for 'DownloadInfo' parseDownloadInfoFromObject :: Object -> WarningParser DownloadInfo parseDownloadInfoFromObject o = do url <- o ..: "url" contentLength <- o ..:? "content-length" sha1TextMay <- o ..:? "sha1" sha256TextMay <- o ..:? "sha256" return DownloadInfo { downloadInfoUrl = url , downloadInfoContentLength = contentLength , downloadInfoSha1 = fmap encodeUtf8 sha1TextMay , downloadInfoSha256 = fmap encodeUtf8 sha256TextMay } data VersionedDownloadInfo = VersionedDownloadInfo { vdiVersion :: Version , vdiDownloadInfo :: DownloadInfo } deriving Show instance FromJSON (WithJSONWarnings VersionedDownloadInfo) where parseJSON = withObjectWarnings "VersionedDownloadInfo" $ \o -> do version <- o ..: "version" downloadInfo <- parseDownloadInfoFromObject o return VersionedDownloadInfo { vdiVersion = version , vdiDownloadInfo = downloadInfo } data GHCDownloadInfo = GHCDownloadInfo { gdiConfigureOpts :: [Text] , gdiConfigureEnv :: Map Text Text , gdiDownloadInfo :: DownloadInfo } deriving Show instance FromJSON (WithJSONWarnings GHCDownloadInfo) where parseJSON = withObjectWarnings "GHCDownloadInfo" $ \o -> do configureOpts <- o ..:? "configure-opts" ..!= mempty configureEnv <- o ..:? "configure-env" ..!= mempty downloadInfo <- parseDownloadInfoFromObject o return GHCDownloadInfo { gdiConfigureOpts = configureOpts , gdiConfigureEnv = configureEnv , gdiDownloadInfo = downloadInfo } data SetupInfo = SetupInfo { siSevenzExe :: Maybe DownloadInfo , siSevenzDll :: Maybe DownloadInfo , siMsys2 :: Map Text VersionedDownloadInfo , siGHCs :: Map Text (Map Version GHCDownloadInfo) , siGHCJSs :: Map Text (Map (CompilerVersion 'CVActual) DownloadInfo) , siStack :: Map Text (Map Version DownloadInfo) } deriving Show instance FromJSON (WithJSONWarnings SetupInfo) where parseJSON = withObjectWarnings "SetupInfo" $ \o -> do siSevenzExe <- jsonSubWarningsT (o ..:? "sevenzexe-info") siSevenzDll <- jsonSubWarningsT (o ..:? "sevenzdll-info") siMsys2 <- jsonSubWarningsT (o ..:? "msys2" ..!= mempty) siGHCs <- jsonSubWarningsTT (o ..:? "ghc" ..!= mempty) siGHCJSs <- jsonSubWarningsTT (o ..:? "ghcjs" ..!= mempty) siStack <- jsonSubWarningsTT (o ..:? "stack" ..!= mempty) return SetupInfo {..} -- | For @siGHCs@ and @siGHCJSs@ fields maps are deeply merged. -- For all fields the values from the last @SetupInfo@ win. instance Semigroup SetupInfo where l <> r = SetupInfo { siSevenzExe = siSevenzExe r <|> siSevenzExe l , siSevenzDll = siSevenzDll r <|> siSevenzDll l , siMsys2 = siMsys2 r <> siMsys2 l , siGHCs = Map.unionWith (<>) (siGHCs r) (siGHCs l) , siGHCJSs = Map.unionWith (<>) (siGHCJSs r) (siGHCJSs l) , siStack = Map.unionWith (<>) (siStack l) (siStack r) } instance Monoid SetupInfo where mempty = SetupInfo { siSevenzExe = Nothing , siSevenzDll = Nothing , siMsys2 = Map.empty , siGHCs = Map.empty , siGHCJSs = Map.empty , siStack = Map.empty } mappend = (<>) -- | Remote or inline 'SetupInfo' data SetupInfoLocation = SetupInfoFileOrURL String | SetupInfoInline SetupInfo deriving (Show) instance FromJSON (WithJSONWarnings SetupInfoLocation) where parseJSON v = (noJSONWarnings <$> withText "SetupInfoFileOrURL" (pure . SetupInfoFileOrURL . T.unpack) v) <|> inline where inline = do WithJSONWarnings si w <- parseJSON v return $ WithJSONWarnings (SetupInfoInline si) w -- | How PVP bounds should be added to .cabal files data PvpBoundsType = PvpBoundsNone | PvpBoundsUpper | PvpBoundsLower | PvpBoundsBoth deriving (Show, Read, Eq, Typeable, Ord, Enum, Bounded) data PvpBounds = PvpBounds { pbType :: !PvpBoundsType , pbAsRevision :: !Bool } deriving (Show, Read, Eq, Typeable, Ord) pvpBoundsText :: PvpBoundsType -> Text pvpBoundsText PvpBoundsNone = "none" pvpBoundsText PvpBoundsUpper = "upper" pvpBoundsText PvpBoundsLower = "lower" pvpBoundsText PvpBoundsBoth = "both" parsePvpBounds :: Text -> Either String PvpBounds parsePvpBounds t = maybe err Right $ do (t', asRevision) <- case T.break (== '-') t of (x, "") -> Just (x, False) (x, "-revision") -> Just (x, True) _ -> Nothing x <- Map.lookup t' m Just PvpBounds { pbType = x , pbAsRevision = asRevision } where m = Map.fromList $ map (pvpBoundsText &&& id) [minBound..maxBound] err = Left $ "Invalid PVP bounds: " ++ T.unpack t instance ToJSON PvpBounds where toJSON (PvpBounds typ asRevision) = toJSON (pvpBoundsText typ <> (if asRevision then "-revision" else "")) instance FromJSON PvpBounds where parseJSON = withText "PvpBounds" (either fail return . parsePvpBounds) -- | Provide an explicit list of package dependencies when running a custom Setup.hs explicitSetupDeps :: (MonadReader env m, HasConfig env) => PackageName -> m Bool explicitSetupDeps name = do m <- view $ configL.to configExplicitSetupDeps return $ -- Yes there are far cleverer ways to write this. I honestly consider -- the explicit pattern matching much easier to parse at a glance. case Map.lookup (Just name) m of Just b -> b Nothing -> case Map.lookup Nothing m of Just b -> b Nothing -> False -- default value -- | Data passed into Docker container for the Docker entrypoint's use newtype DockerEntrypoint = DockerEntrypoint { deUser :: Maybe DockerUser -- ^ UID/GID/etc of host user, if we wish to perform UID/GID switch in container } deriving (Read,Show) -- | Docker host user info data DockerUser = DockerUser { duUid :: UserID -- ^ uid , duGid :: GroupID -- ^ gid , duGroups :: [GroupID] -- ^ Supplemantal groups , duUmask :: FileMode -- ^ File creation mask } } deriving (Read,Show) data GhcOptionKey = GOKOldEverything | GOKEverything | GOKLocals | GOKTargets | GOKPackage !PackageName deriving (Eq, Ord) instance FromJSONKey GhcOptionKey where fromJSONKey = FromJSONKeyTextParser $ \t -> case t of "*" -> return GOKOldEverything "$everything" -> return GOKEverything "$locals" -> return GOKLocals "$targets" -> return GOKTargets _ -> case parsePackageName t of Left e -> fail $ show e Right x -> return $ GOKPackage x fromJSONKeyList = FromJSONKeyTextParser $ \_ -> fail "GhcOptionKey.fromJSONKeyList" newtype GhcOptions = GhcOptions { unGhcOptions :: [Text] } instance FromJSON GhcOptions where parseJSON = withText "GhcOptions" $ \t -> case parseArgs Escaping t of Left e -> fail e Right opts -> return $ GhcOptions $ map T.pack opts ----------------------------------- -- Lens classes ----------------------------------- -- | Class for environment values which have a Platform class HasPlatform env where platformL :: Lens' env Platform default platformL :: HasConfig env => Lens' env Platform platformL = configL.platformL {-# INLINE platformL #-} platformVariantL :: Lens' env PlatformVariant default platformVariantL :: HasConfig env => Lens' env PlatformVariant platformVariantL = configL.platformVariantL {-# INLINE platformVariantL #-} -- | Class for environment values which have a GHCVariant class HasGHCVariant env where ghcVariantL :: Lens' env GHCVariant default ghcVariantL :: HasBuildConfig env => Lens' env GHCVariant ghcVariantL = buildConfigL.ghcVariantL {-# INLINE ghcVariantL #-} -- | Class for environment values that can provide a 'Config'. class (HasPlatform env, HasProcessContext env, HasCabalLoader env) => HasConfig env where configL :: Lens' env Config default configL :: HasBuildConfig env => Lens' env Config configL = buildConfigL.lens bcConfig (\x y -> x { bcConfig = y }) {-# INLINE configL #-} class HasConfig env => HasBuildConfig env where buildConfigL :: Lens' env BuildConfig default buildConfigL :: HasEnvConfig env => Lens' env BuildConfig buildConfigL = envConfigL.lens envConfigBuildConfig (\x y -> x { envConfigBuildConfig = y }) class (HasBuildConfig env, HasGHCVariant env) => HasEnvConfig env where envConfigL :: Lens' env EnvConfig ----------------------------------- -- Lens instances ----------------------------------- instance HasPlatform (Platform,PlatformVariant) where platformL = _1 platformVariantL = _2 instance HasPlatform Config where platformL = lens configPlatform (\x y -> x { configPlatform = y }) platformVariantL = lens configPlatformVariant (\x y -> x { configPlatformVariant = y }) instance HasPlatform LoadConfig instance HasPlatform BuildConfig instance HasPlatform EnvConfig instance HasGHCVariant GHCVariant where ghcVariantL = id {-# INLINE ghcVariantL #-} instance HasGHCVariant BuildConfig where ghcVariantL = lens bcGHCVariant (\x y -> x { bcGHCVariant = y }) instance HasGHCVariant EnvConfig instance HasProcessContext Config where processContextL = runnerL.processContextL instance HasProcessContext LoadConfig where processContextL = configL.processContextL instance HasProcessContext BuildConfig where processContextL = configL.processContextL instance HasProcessContext EnvConfig where processContextL = configL.processContextL instance HasCabalLoader Config where cabalLoaderL = lens configCabalLoader (\x y -> x { configCabalLoader = y }) instance HasCabalLoader LoadConfig where cabalLoaderL = configL.cabalLoaderL instance HasCabalLoader BuildConfig where cabalLoaderL = configL.cabalLoaderL instance HasCabalLoader EnvConfig where cabalLoaderL = configL.cabalLoaderL instance HasConfig Config where configL = id {-# INLINE configL #-} instance HasConfig LoadConfig where configL = lens lcConfig (\x y -> x { lcConfig = y }) instance HasConfig BuildConfig where configL = lens bcConfig (\x y -> x { bcConfig = y }) instance HasConfig EnvConfig instance HasBuildConfig BuildConfig where buildConfigL = id {-# INLINE buildConfigL #-} instance HasBuildConfig EnvConfig instance HasEnvConfig EnvConfig where envConfigL = id {-# INLINE envConfigL #-} instance HasRunner Config where runnerL = lens configRunner (\x y -> x { configRunner = y }) instance HasRunner LoadConfig where runnerL = configL.runnerL instance HasRunner BuildConfig where runnerL = configL.runnerL instance HasRunner EnvConfig where runnerL = configL.runnerL instance HasLogFunc Config where logFuncL = runnerL.logFuncL instance HasLogFunc LoadConfig where logFuncL = runnerL.logFuncL instance HasLogFunc BuildConfig where logFuncL = runnerL.logFuncL instance HasLogFunc EnvConfig where logFuncL = runnerL.logFuncL ----------------------------------- -- Helper lenses ----------------------------------- stackRootL :: HasCabalLoader s => Lens' s (Path Abs Dir) stackRootL = cabalLoaderL.lens clStackRoot (\x y -> x { clStackRoot = y }) -- | The compiler specified by the @SnapshotDef@. This may be -- different from the actual compiler used! wantedCompilerVersionL :: HasBuildConfig s => Getting r s (CompilerVersion 'CVWanted) wantedCompilerVersionL = snapshotDefL.to sdWantedCompilerVersion -- | The version of the compiler which will actually be used. May be -- different than that specified in the 'SnapshotDef' and returned -- by 'wantedCompilerVersionL'. actualCompilerVersionL :: HasEnvConfig s => Lens' s (CompilerVersion 'CVActual) actualCompilerVersionL = envConfigL.lens envConfigCompilerVersion (\x y -> x { envConfigCompilerVersion = y }) snapshotDefL :: HasBuildConfig s => Lens' s SnapshotDef snapshotDefL = buildConfigL.lens bcSnapshotDef (\x y -> x { bcSnapshotDef = y }) buildOptsL :: HasConfig s => Lens' s BuildOpts buildOptsL = configL.lens configBuild (\x y -> x { configBuild = y }) buildOptsMonoidHaddockL :: Lens' BuildOptsMonoid (Maybe Bool) buildOptsMonoidHaddockL = lens (getFirst . buildMonoidHaddock) (\buildMonoid t -> buildMonoid {buildMonoidHaddock = First t}) buildOptsMonoidTestsL :: Lens' BuildOptsMonoid (Maybe Bool) buildOptsMonoidTestsL = lens (getFirst . buildMonoidTests) (\buildMonoid t -> buildMonoid {buildMonoidTests = First t}) buildOptsMonoidBenchmarksL :: Lens' BuildOptsMonoid (Maybe Bool) buildOptsMonoidBenchmarksL = lens (getFirst . buildMonoidBenchmarks) (\buildMonoid t -> buildMonoid {buildMonoidBenchmarks = First t}) buildOptsMonoidInstallExesL :: Lens' BuildOptsMonoid (Maybe Bool) buildOptsMonoidInstallExesL = lens (getFirst . buildMonoidInstallExes) (\buildMonoid t -> buildMonoid {buildMonoidInstallExes = First t}) buildOptsInstallExesL :: Lens' BuildOpts Bool buildOptsInstallExesL = lens boptsInstallExes (\bopts t -> bopts {boptsInstallExes = t}) buildOptsHaddockL :: Lens' BuildOpts Bool buildOptsHaddockL = lens boptsHaddock (\bopts t -> bopts {boptsHaddock = t}) globalOptsL :: Lens' GlobalOpts ConfigMonoid globalOptsL = lens globalConfigMonoid (\x y -> x { globalConfigMonoid = y }) globalOptsBuildOptsMonoidL :: Lens' GlobalOpts BuildOptsMonoid globalOptsBuildOptsMonoidL = globalOptsL.lens configMonoidBuildOpts (\x y -> x { configMonoidBuildOpts = y }) configUrlsL :: HasConfig env => Lens' env Urls configUrlsL = configL.lens configUrls (\x y -> x { configUrls = y }) cabalVersionL :: HasEnvConfig env => Lens' env Version cabalVersionL = envConfigL.lens envConfigCabalVersion (\x y -> x { envConfigCabalVersion = y }) loadedSnapshotL :: HasEnvConfig env => Lens' env LoadedSnapshot loadedSnapshotL = envConfigL.lens envConfigLoadedSnapshot (\x y -> x { envConfigLoadedSnapshot = y }) whichCompilerL :: Getting r (CompilerVersion a) WhichCompiler whichCompilerL = to whichCompiler envOverrideSettingsL :: HasConfig env => Lens' env (EnvSettings -> IO ProcessContext) envOverrideSettingsL = configL.lens configProcessContextSettings (\x y -> x { configProcessContextSettings = y }) globalHintsL :: HasBuildConfig s => Getting r s (Map PackageName (Maybe Version)) globalHintsL = snapshotDefL.to sdGlobalHints shouldForceGhcColorFlag :: (HasRunner env, HasEnvConfig env) => RIO env Bool shouldForceGhcColorFlag = do canDoColor <- (>= $(mkVersion "8.2.1")) . getGhcVersion <$> view actualCompilerVersionL shouldDoColor <- view useColorL return $ canDoColor && shouldDoColor appropriateGhcColorFlag :: (HasRunner env, HasEnvConfig env) => RIO env (Maybe String) appropriateGhcColorFlag = f <$> shouldForceGhcColorFlag where f True = Just ghcColorForceFlag f False = Nothing stack-1.9.3.1/src/Stack/Types/Config/Build.hs0000644000000000000000000003727613455617610016745 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude #-} {-# LANGUAGE DeriveGeneric #-} {-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE RecordWildCards #-} -- | Configuration options for building. module Stack.Types.Config.Build ( BuildOpts(..) , BuildCommand(..) , defaultBuildOpts , defaultBuildOptsCLI , BuildOptsCLI(..) , BuildOptsMonoid(..) , TestOpts(..) , defaultTestOpts , TestOptsMonoid(..) , HaddockOpts(..) , defaultHaddockOpts , HaddockOptsMonoid(..) , BenchmarkOpts(..) , defaultBenchmarkOpts , BenchmarkOptsMonoid(..) , FileWatchOpts(..) , BuildSubset(..) ) where import Data.Aeson.Extended import qualified Data.Map.Strict as Map import Generics.Deriving.Monoid (memptydefault, mappenddefault) import Stack.Prelude import Stack.Types.FlagName import Stack.Types.PackageName -- | Build options that is interpreted by the build command. -- This is built up from BuildOptsCLI and BuildOptsMonoid data BuildOpts = BuildOpts {boptsLibProfile :: !Bool ,boptsExeProfile :: !Bool ,boptsLibStrip :: !Bool ,boptsExeStrip :: !Bool ,boptsHaddock :: !Bool -- ^ Build haddocks? ,boptsHaddockOpts :: !HaddockOpts -- ^ Options to pass to haddock ,boptsOpenHaddocks :: !Bool -- ^ Open haddocks in the browser? ,boptsHaddockDeps :: !(Maybe Bool) -- ^ Build haddocks for dependencies? ,boptsHaddockInternal :: !Bool -- ^ Build haddocks for all symbols and packages, like @cabal haddock --internal@ ,boptsHaddockHyperlinkSource :: !Bool -- ^ Build hyperlinked source if possible. Fallback to -- @hscolour@. Disable for no sources. ,boptsInstallExes :: !Bool -- ^ Install executables to user path after building? ,boptsInstallCompilerTool :: !Bool -- ^ Install executables to compiler tools path after building? ,boptsPreFetch :: !Bool -- ^ Fetch all packages immediately -- ^ Watch files for changes and automatically rebuild ,boptsKeepGoing :: !(Maybe Bool) -- ^ Keep building/running after failure ,boptsKeepTmpFiles :: !(Maybe Bool) -- ^ Keep intermediate files and build directories ,boptsForceDirty :: !Bool -- ^ Force treating all local packages as having dirty files ,boptsTests :: !Bool -- ^ Turn on tests for local targets ,boptsTestOpts :: !TestOpts -- ^ Additional test arguments ,boptsBenchmarks :: !Bool -- ^ Turn on benchmarks for local targets ,boptsBenchmarkOpts :: !BenchmarkOpts -- ^ Additional test arguments -- ^ Commands (with arguments) to run after a successful build -- ^ Only perform the configure step when building ,boptsReconfigure :: !Bool -- ^ Perform the configure step even if already configured ,boptsCabalVerbose :: !Bool -- ^ Ask Cabal to be verbose in its builds ,boptsSplitObjs :: !Bool -- ^ Whether to enable split-objs. ,boptsSkipComponents :: ![Text] -- ^ Which components to skip when building ,boptsInterleavedOutput :: !Bool -- ^ Should we use the interleaved GHC output when building -- multiple packages? } deriving (Show) defaultBuildOpts :: BuildOpts defaultBuildOpts = BuildOpts { boptsLibProfile = False , boptsExeProfile = False , boptsLibStrip = True , boptsExeStrip = True , boptsHaddock = False , boptsHaddockOpts = defaultHaddockOpts , boptsOpenHaddocks = False , boptsHaddockDeps = Nothing , boptsHaddockInternal = False , boptsHaddockHyperlinkSource = True , boptsInstallExes = False , boptsInstallCompilerTool = False , boptsPreFetch = False , boptsKeepGoing = Nothing , boptsKeepTmpFiles = Nothing , boptsForceDirty = False , boptsTests = False , boptsTestOpts = defaultTestOpts , boptsBenchmarks = False , boptsBenchmarkOpts = defaultBenchmarkOpts , boptsReconfigure = False , boptsCabalVerbose = False , boptsSplitObjs = False , boptsSkipComponents = [] , boptsInterleavedOutput = False } defaultBuildOptsCLI ::BuildOptsCLI defaultBuildOptsCLI = BuildOptsCLI { boptsCLITargets = [] , boptsCLIDryrun = False , boptsCLIFlags = Map.empty , boptsCLIGhcOptions = [] , boptsCLIBuildSubset = BSAll , boptsCLIFileWatch = NoFileWatch , boptsCLIExec = [] , boptsCLIOnlyConfigure = False , boptsCLICommand = Build , boptsCLIInitialBuildSteps = False } -- | Build options that may only be specified from the CLI data BuildOptsCLI = BuildOptsCLI { boptsCLITargets :: ![Text] , boptsCLIDryrun :: !Bool , boptsCLIGhcOptions :: ![Text] , boptsCLIFlags :: !(Map (Maybe PackageName) (Map FlagName Bool)) , boptsCLIBuildSubset :: !BuildSubset , boptsCLIFileWatch :: !FileWatchOpts , boptsCLIExec :: ![(String, [String])] , boptsCLIOnlyConfigure :: !Bool , boptsCLICommand :: !BuildCommand , boptsCLIInitialBuildSteps :: !Bool } deriving Show -- | Command sum type for conditional arguments. data BuildCommand = Build | Test | Haddock | Bench | Install deriving (Eq, Show) -- | Build options that may be specified in the stack.yaml or from the CLI data BuildOptsMonoid = BuildOptsMonoid { buildMonoidTrace :: !Any , buildMonoidProfile :: !Any , buildMonoidNoStrip :: !Any , buildMonoidLibProfile :: !(First Bool) , buildMonoidExeProfile :: !(First Bool) , buildMonoidLibStrip :: !(First Bool) , buildMonoidExeStrip :: !(First Bool) , buildMonoidHaddock :: !(First Bool) , buildMonoidHaddockOpts :: !HaddockOptsMonoid , buildMonoidOpenHaddocks :: !(First Bool) , buildMonoidHaddockDeps :: !(First Bool) , buildMonoidHaddockInternal :: !(First Bool) , buildMonoidHaddockHyperlinkSource :: !(First Bool) , buildMonoidInstallExes :: !(First Bool) , buildMonoidInstallCompilerTool :: !(First Bool) , buildMonoidPreFetch :: !(First Bool) , buildMonoidKeepGoing :: !(First Bool) , buildMonoidKeepTmpFiles :: !(First Bool) , buildMonoidForceDirty :: !(First Bool) , buildMonoidTests :: !(First Bool) , buildMonoidTestOpts :: !TestOptsMonoid , buildMonoidBenchmarks :: !(First Bool) , buildMonoidBenchmarkOpts :: !BenchmarkOptsMonoid , buildMonoidReconfigure :: !(First Bool) , buildMonoidCabalVerbose :: !(First Bool) , buildMonoidSplitObjs :: !(First Bool) , buildMonoidSkipComponents :: ![Text] , buildMonoidInterleavedOutput :: !(First Bool) } deriving (Show, Generic) instance FromJSON (WithJSONWarnings BuildOptsMonoid) where parseJSON = withObjectWarnings "BuildOptsMonoid" (\o -> do let buildMonoidTrace = Any False buildMonoidProfile = Any False buildMonoidNoStrip = Any False buildMonoidLibProfile <- First <$> o ..:? buildMonoidLibProfileArgName buildMonoidExeProfile <-First <$> o ..:? buildMonoidExeProfileArgName buildMonoidLibStrip <- First <$> o ..:? buildMonoidLibStripArgName buildMonoidExeStrip <-First <$> o ..:? buildMonoidExeStripArgName buildMonoidHaddock <- First <$> o ..:? buildMonoidHaddockArgName buildMonoidHaddockOpts <- jsonSubWarnings (o ..:? buildMonoidHaddockOptsArgName ..!= mempty) buildMonoidOpenHaddocks <- First <$> o ..:? buildMonoidOpenHaddocksArgName buildMonoidHaddockDeps <- First <$> o ..:? buildMonoidHaddockDepsArgName buildMonoidHaddockInternal <- First <$> o ..:? buildMonoidHaddockInternalArgName buildMonoidHaddockHyperlinkSource <- First <$> o ..:? buildMonoidHaddockHyperlinkSourceArgName buildMonoidInstallExes <- First <$> o ..:? buildMonoidInstallExesArgName buildMonoidInstallCompilerTool <- First <$> o ..:? buildMonoidInstallCompilerToolArgName buildMonoidPreFetch <- First <$> o ..:? buildMonoidPreFetchArgName buildMonoidKeepGoing <- First <$> o ..:? buildMonoidKeepGoingArgName buildMonoidKeepTmpFiles <- First <$> o ..:? buildMonoidKeepTmpFilesArgName buildMonoidForceDirty <- First <$> o ..:? buildMonoidForceDirtyArgName buildMonoidTests <- First <$> o ..:? buildMonoidTestsArgName buildMonoidTestOpts <- jsonSubWarnings (o ..:? buildMonoidTestOptsArgName ..!= mempty) buildMonoidBenchmarks <- First <$> o ..:? buildMonoidBenchmarksArgName buildMonoidBenchmarkOpts <- jsonSubWarnings (o ..:? buildMonoidBenchmarkOptsArgName ..!= mempty) buildMonoidReconfigure <- First <$> o ..:? buildMonoidReconfigureArgName buildMonoidCabalVerbose <- First <$> o ..:? buildMonoidCabalVerboseArgName buildMonoidSplitObjs <- First <$> o ..:? buildMonoidSplitObjsName buildMonoidSkipComponents <- o ..:? buildMonoidSkipComponentsName ..!= mempty buildMonoidInterleavedOutput <- First <$> o ..:? buildMonoidInterleavedOutputName return BuildOptsMonoid{..}) buildMonoidLibProfileArgName :: Text buildMonoidLibProfileArgName = "library-profiling" buildMonoidExeProfileArgName :: Text buildMonoidExeProfileArgName = "executable-profiling" buildMonoidLibStripArgName :: Text buildMonoidLibStripArgName = "library-stripping" buildMonoidExeStripArgName :: Text buildMonoidExeStripArgName = "executable-stripping" buildMonoidHaddockArgName :: Text buildMonoidHaddockArgName = "haddock" buildMonoidHaddockOptsArgName :: Text buildMonoidHaddockOptsArgName = "haddock-arguments" buildMonoidOpenHaddocksArgName :: Text buildMonoidOpenHaddocksArgName = "open-haddocks" buildMonoidHaddockDepsArgName :: Text buildMonoidHaddockDepsArgName = "haddock-deps" buildMonoidHaddockInternalArgName :: Text buildMonoidHaddockInternalArgName = "haddock-internal" buildMonoidHaddockHyperlinkSourceArgName :: Text buildMonoidHaddockHyperlinkSourceArgName = "haddock-hyperlink-source" buildMonoidInstallExesArgName :: Text buildMonoidInstallExesArgName = "copy-bins" buildMonoidInstallCompilerToolArgName :: Text buildMonoidInstallCompilerToolArgName = "copy-compiler-tool" buildMonoidPreFetchArgName :: Text buildMonoidPreFetchArgName = "prefetch" buildMonoidKeepGoingArgName :: Text buildMonoidKeepGoingArgName = "keep-going" buildMonoidKeepTmpFilesArgName :: Text buildMonoidKeepTmpFilesArgName = "keep-tmp-files" buildMonoidForceDirtyArgName :: Text buildMonoidForceDirtyArgName = "force-dirty" buildMonoidTestsArgName :: Text buildMonoidTestsArgName = "test" buildMonoidTestOptsArgName :: Text buildMonoidTestOptsArgName = "test-arguments" buildMonoidBenchmarksArgName :: Text buildMonoidBenchmarksArgName = "bench" buildMonoidBenchmarkOptsArgName :: Text buildMonoidBenchmarkOptsArgName = "benchmark-opts" buildMonoidReconfigureArgName :: Text buildMonoidReconfigureArgName = "reconfigure" buildMonoidCabalVerboseArgName :: Text buildMonoidCabalVerboseArgName = "cabal-verbose" buildMonoidSplitObjsName :: Text buildMonoidSplitObjsName = "split-objs" buildMonoidSkipComponentsName :: Text buildMonoidSkipComponentsName = "skip-components" buildMonoidInterleavedOutputName :: Text buildMonoidInterleavedOutputName = "interleaved-output" instance Semigroup BuildOptsMonoid where (<>) = mappenddefault instance Monoid BuildOptsMonoid where mempty = memptydefault mappend = (<>) -- | Which subset of packages to build data BuildSubset = BSAll | BSOnlySnapshot -- ^ Only install packages in the snapshot database, skipping -- packages intended for the local database. | BSOnlyDependencies deriving (Show, Eq) -- | Options for the 'FinalAction' 'DoTests' data TestOpts = TestOpts {toRerunTests :: !Bool -- ^ Whether successful tests will be run gain ,toAdditionalArgs :: ![String] -- ^ Arguments passed to the test program ,toCoverage :: !Bool -- ^ Generate a code coverage report ,toDisableRun :: !Bool -- ^ Disable running of tests } deriving (Eq,Show) defaultTestOpts :: TestOpts defaultTestOpts = TestOpts { toRerunTests = True , toAdditionalArgs = [] , toCoverage = False , toDisableRun = False } data TestOptsMonoid = TestOptsMonoid { toMonoidRerunTests :: !(First Bool) , toMonoidAdditionalArgs :: ![String] , toMonoidCoverage :: !(First Bool) , toMonoidDisableRun :: !(First Bool) } deriving (Show, Generic) instance FromJSON (WithJSONWarnings TestOptsMonoid) where parseJSON = withObjectWarnings "TestOptsMonoid" (\o -> do toMonoidRerunTests <- First <$> o ..:? toMonoidRerunTestsArgName toMonoidAdditionalArgs <- o ..:? toMonoidAdditionalArgsName ..!= [] toMonoidCoverage <- First <$> o ..:? toMonoidCoverageArgName toMonoidDisableRun <- First <$> o ..:? toMonoidDisableRunArgName return TestOptsMonoid{..}) toMonoidRerunTestsArgName :: Text toMonoidRerunTestsArgName = "rerun-tests" toMonoidAdditionalArgsName :: Text toMonoidAdditionalArgsName = "additional-args" toMonoidCoverageArgName :: Text toMonoidCoverageArgName = "coverage" toMonoidDisableRunArgName :: Text toMonoidDisableRunArgName = "no-run-tests" instance Semigroup TestOptsMonoid where (<>) = mappenddefault instance Monoid TestOptsMonoid where mempty = memptydefault mappend = (<>) -- | Haddock Options newtype HaddockOpts = HaddockOpts { hoAdditionalArgs :: [String] -- ^ Arguments passed to haddock program } deriving (Eq,Show) newtype HaddockOptsMonoid = HaddockOptsMonoid {hoMonoidAdditionalArgs :: [String] } deriving (Show, Generic) defaultHaddockOpts :: HaddockOpts defaultHaddockOpts = HaddockOpts {hoAdditionalArgs = []} instance FromJSON (WithJSONWarnings HaddockOptsMonoid) where parseJSON = withObjectWarnings "HaddockOptsMonoid" (\o -> do hoMonoidAdditionalArgs <- o ..:? hoMonoidAdditionalArgsName ..!= [] return HaddockOptsMonoid{..}) instance Semigroup HaddockOptsMonoid where (<>) = mappenddefault instance Monoid HaddockOptsMonoid where mempty = memptydefault mappend = (<>) hoMonoidAdditionalArgsName :: Text hoMonoidAdditionalArgsName = "haddock-args" -- | Options for the 'FinalAction' 'DoBenchmarks' data BenchmarkOpts = BenchmarkOpts { beoAdditionalArgs :: !(Maybe String) -- ^ Arguments passed to the benchmark program , beoDisableRun :: !Bool -- ^ Disable running of benchmarks } deriving (Eq,Show) defaultBenchmarkOpts :: BenchmarkOpts defaultBenchmarkOpts = BenchmarkOpts { beoAdditionalArgs = Nothing , beoDisableRun = False } data BenchmarkOptsMonoid = BenchmarkOptsMonoid { beoMonoidAdditionalArgs :: !(First String) , beoMonoidDisableRun :: !(First Bool) } deriving (Show, Generic) instance FromJSON (WithJSONWarnings BenchmarkOptsMonoid) where parseJSON = withObjectWarnings "BenchmarkOptsMonoid" (\o -> do beoMonoidAdditionalArgs <- First <$> o ..:? beoMonoidAdditionalArgsArgName beoMonoidDisableRun <- First <$> o ..:? beoMonoidDisableRunArgName return BenchmarkOptsMonoid{..}) beoMonoidAdditionalArgsArgName :: Text beoMonoidAdditionalArgsArgName = "benchmark-arguments" beoMonoidDisableRunArgName :: Text beoMonoidDisableRunArgName = "no-run-benchmarks" instance Semigroup BenchmarkOptsMonoid where (<>) = mappenddefault instance Monoid BenchmarkOptsMonoid where mempty = memptydefault mappend = (<>) data FileWatchOpts = NoFileWatch | FileWatch | FileWatchPoll deriving (Show,Eq) stack-1.9.3.1/src/Stack/Types/Docker.hs0000644000000000000000000004326713455617610015705 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude #-} {-# LANGUAGE DeriveDataTypeable #-} {-# LANGUAGE DeriveGeneric #-} {-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE RecordWildCards #-} -- | Docker types. module Stack.Types.Docker where import Stack.Prelude hiding (Display (..)) import Data.Aeson.Extended import Data.List (intercalate) import qualified Data.Text as T import Distribution.System (Platform(..), OS(..), Arch(..)) import Distribution.Text (simpleParse, display) import Distribution.Version (anyVersion) import Generics.Deriving.Monoid (mappenddefault, memptydefault) import Path import Stack.Constants import Stack.Types.Version import Text.Read (Read (..)) -- | Docker configuration. data DockerOpts = DockerOpts {dockerEnable :: !Bool -- ^ Is using Docker enabled? ,dockerImage :: !String -- ^ Exact Docker image tag or ID. Overrides docker-repo-*/tag. ,dockerRegistryLogin :: !Bool -- ^ Does registry require login for pulls? ,dockerRegistryUsername :: !(Maybe String) -- ^ Optional username for Docker registry. ,dockerRegistryPassword :: !(Maybe String) -- ^ Optional password for Docker registry. ,dockerAutoPull :: !Bool -- ^ Automatically pull new images. ,dockerDetach :: !Bool -- ^ Whether to run a detached container ,dockerPersist :: !Bool -- ^ Create a persistent container (don't remove it when finished). Implied by -- `dockerDetach`. ,dockerContainerName :: !(Maybe String) -- ^ Container name to use, only makes sense from command-line with `dockerPersist` -- or `dockerDetach`. ,dockerRunArgs :: ![String] -- ^ Arguments to pass directly to @docker run@. ,dockerMount :: ![Mount] -- ^ Volumes to mount in the container. ,dockerEnv :: ![String] -- ^ Environment variables to set in the container. ,dockerDatabasePath :: !(Path Abs File) -- ^ Location of image usage database. ,dockerStackExe :: !(Maybe DockerStackExe) -- ^ Location of container-compatible stack executable ,dockerSetUser :: !(Maybe Bool) -- ^ Set in-container user to match host's ,dockerRequireDockerVersion :: !VersionRange -- ^ Require a version of Docker within this range. } deriving (Show) -- | An uninterpreted representation of docker options. -- Configurations may be "cascaded" using mappend (left-biased). data DockerOptsMonoid = DockerOptsMonoid {dockerMonoidDefaultEnable :: !Any -- ^ Should Docker be defaulted to enabled (does @docker:@ section exist in the config)? ,dockerMonoidEnable :: !(First Bool) -- ^ Is using Docker enabled? ,dockerMonoidRepoOrImage :: !(First DockerMonoidRepoOrImage) -- ^ Docker repository name (e.g. @fpco/stack-build@ or @fpco/stack-full:lts-2.8@) ,dockerMonoidRegistryLogin :: !(First Bool) -- ^ Does registry require login for pulls? ,dockerMonoidRegistryUsername :: !(First String) -- ^ Optional username for Docker registry. ,dockerMonoidRegistryPassword :: !(First String) -- ^ Optional password for Docker registry. ,dockerMonoidAutoPull :: !(First Bool) -- ^ Automatically pull new images. ,dockerMonoidDetach :: !(First Bool) -- ^ Whether to run a detached container ,dockerMonoidPersist :: !(First Bool) -- ^ Create a persistent container (don't remove it when finished). Implied by -- `dockerDetach`. ,dockerMonoidContainerName :: !(First String) -- ^ Container name to use, only makes sense from command-line with `dockerPersist` -- or `dockerDetach`. ,dockerMonoidRunArgs :: ![String] -- ^ Arguments to pass directly to @docker run@ ,dockerMonoidMount :: ![Mount] -- ^ Volumes to mount in the container ,dockerMonoidEnv :: ![String] -- ^ Environment variables to set in the container ,dockerMonoidDatabasePath :: !(First (Path Abs File)) -- ^ Location of image usage database. ,dockerMonoidStackExe :: !(First DockerStackExe) -- ^ Location of container-compatible stack executable ,dockerMonoidSetUser :: !(First Bool) -- ^ Set in-container user to match host's ,dockerMonoidRequireDockerVersion :: !IntersectingVersionRange -- ^ See: 'dockerRequireDockerVersion' } deriving (Show, Generic) -- | Decode uninterpreted docker options from JSON/YAML. instance FromJSON (WithJSONWarnings DockerOptsMonoid) where parseJSON = withObjectWarnings "DockerOptsMonoid" (\o -> do let dockerMonoidDefaultEnable = Any True dockerMonoidEnable <- First <$> o ..:? dockerEnableArgName dockerMonoidRepoOrImage <- First <$> ((Just . DockerMonoidImage <$> o ..: dockerImageArgName) <|> (Just . DockerMonoidRepo <$> o ..: dockerRepoArgName) <|> pure Nothing) dockerMonoidRegistryLogin <- First <$> o ..:? dockerRegistryLoginArgName dockerMonoidRegistryUsername <- First <$> o ..:? dockerRegistryUsernameArgName dockerMonoidRegistryPassword <- First <$> o ..:? dockerRegistryPasswordArgName dockerMonoidAutoPull <- First <$> o ..:? dockerAutoPullArgName dockerMonoidDetach <- First <$> o ..:? dockerDetachArgName dockerMonoidPersist <- First <$> o ..:? dockerPersistArgName dockerMonoidContainerName <- First <$> o ..:? dockerContainerNameArgName dockerMonoidRunArgs <- o ..:? dockerRunArgsArgName ..!= [] dockerMonoidMount <- o ..:? dockerMountArgName ..!= [] dockerMonoidEnv <- o ..:? dockerEnvArgName ..!= [] dockerMonoidDatabasePath <- First <$> o ..:? dockerDatabasePathArgName dockerMonoidStackExe <- First <$> o ..:? dockerStackExeArgName dockerMonoidSetUser <- First <$> o ..:? dockerSetUserArgName dockerMonoidRequireDockerVersion <- IntersectingVersionRange . unVersionRangeJSON <$> ( o ..:? dockerRequireDockerVersionArgName ..!= VersionRangeJSON anyVersion) return DockerOptsMonoid{..}) -- | Left-biased combine Docker options instance Semigroup DockerOptsMonoid where (<>) = mappenddefault -- | Left-biased combine Docker options instance Monoid DockerOptsMonoid where mempty = memptydefault mappend = (<>) -- | Where to get the `stack` executable to run in Docker containers data DockerStackExe = DockerStackExeDownload -- ^ Download from official bindist | DockerStackExeHost -- ^ Host's `stack` (linux-x86_64 only) | DockerStackExeImage -- ^ Docker image's `stack` (versions must match) | DockerStackExePath (Path Abs File) -- ^ Executable at given path deriving (Show) instance FromJSON DockerStackExe where parseJSON a = do s <- parseJSON a case parseDockerStackExe s of Right dse -> return dse Left e -> fail (show e) -- | Parse 'DockerStackExe'. parseDockerStackExe :: (MonadThrow m) => String -> m DockerStackExe parseDockerStackExe t | t == dockerStackExeDownloadVal = return DockerStackExeDownload | t == dockerStackExeHostVal = return DockerStackExeHost | t == dockerStackExeImageVal = return DockerStackExeImage | otherwise = case parseAbsFile t of Just p -> return (DockerStackExePath p) Nothing -> throwM (DockerStackExeParseException t) -- | Docker volume mount. data Mount = Mount String String -- | For optparse-applicative. instance Read Mount where readsPrec _ s = case break (== ':') s of (a,':':b) -> [(Mount a b,"")] (a,[]) -> [(Mount a a,"")] _ -> fail "Invalid value for Docker mount (expect '/host/path:/container/path')" -- | Show instance. instance Show Mount where show (Mount a b) = if a == b then a else concat [a,":",b] -- | For YAML. instance FromJSON Mount where parseJSON v = do s <- parseJSON v case readMaybe s of Nothing -> fail $ "Mount read failed: " ++ s Just x -> return x -- | Options for Docker repository or image. data DockerMonoidRepoOrImage = DockerMonoidRepo String | DockerMonoidImage String deriving (Show) -- | Newtype for non-orphan FromJSON instance. newtype VersionRangeJSON = VersionRangeJSON { unVersionRangeJSON :: VersionRange } -- | Parse VersionRange. instance FromJSON VersionRangeJSON where parseJSON = withText "VersionRange" (\s -> maybe (fail ("Invalid cabal-style VersionRange: " ++ T.unpack s)) (return . VersionRangeJSON) (Distribution.Text.simpleParse (T.unpack s))) -- | Exceptions thrown by Stack.Docker. data StackDockerException = DockerMustBeEnabledException -- ^ Docker must be enabled to use the command. | OnlyOnHostException -- ^ Command must be run on host OS (not in a container). | InspectFailedException String -- ^ @docker inspect@ failed. | NotPulledException String -- ^ Image does not exist. | InvalidCleanupCommandException String -- ^ Input to @docker cleanup@ has invalid command. | InvalidImagesOutputException String -- ^ Invalid output from @docker images@. | InvalidPSOutputException String -- ^ Invalid output from @docker ps@. | InvalidInspectOutputException String -- ^ Invalid output from @docker inspect@. | PullFailedException String -- ^ Could not pull a Docker image. | DockerTooOldException Version Version -- ^ Installed version of @docker@ below minimum version. | DockerVersionProhibitedException [Version] Version -- ^ Installed version of @docker@ is prohibited. | BadDockerVersionException VersionRange Version -- ^ Installed version of @docker@ is out of range specified in config file. | InvalidVersionOutputException -- ^ Invalid output from @docker --version@. | HostStackTooOldException Version (Maybe Version) -- ^ Version of @stack@ on host is too old for version in image. | ContainerStackTooOldException Version Version -- ^ Version of @stack@ in container/image is too old for version on host. | CannotDetermineProjectRootException -- ^ Can't determine the project root (where to put docker sandbox). | DockerNotInstalledException -- ^ @docker --version@ failed. | UnsupportedStackExeHostPlatformException -- ^ Using host stack-exe on unsupported platform. | DockerStackExeParseException String -- ^ @stack-exe@ option fails to parse. deriving (Typeable) instance Exception StackDockerException instance Show StackDockerException where show DockerMustBeEnabledException = "Docker must be enabled in your configuration file to use this command." show OnlyOnHostException = "This command must be run on host OS (not in a Docker container)." show (InspectFailedException image) = concat ["'docker inspect' failed for image after pull: ",image,"."] show (NotPulledException image) = concat ["The Docker image referenced by your configuration file" ," has not\nbeen downloaded:\n " ,image ,"\n\nRun '" ,unwords [stackProgName, dockerCmdName, dockerPullCmdName] ,"' to download it, then try again."] show (InvalidCleanupCommandException line) = concat ["Invalid line in cleanup commands: '",line,"'."] show (InvalidImagesOutputException line) = concat ["Invalid 'docker images' output line: '",line,"'."] show (InvalidPSOutputException line) = concat ["Invalid 'docker ps' output line: '",line,"'."] show (InvalidInspectOutputException msg) = concat ["Invalid 'docker inspect' output: ",msg,"."] show (PullFailedException image) = concat ["Could not pull Docker image:\n " ,image ,"\nThere may not be an image on the registry for your resolver's LTS version in\n" ,"your configuration file."] show (DockerTooOldException minVersion haveVersion) = concat ["Minimum docker version '" ,versionString minVersion ,"' is required by " ,stackProgName ," (you have '" ,versionString haveVersion ,"')."] show (DockerVersionProhibitedException prohibitedVersions haveVersion) = concat ["These Docker versions are incompatible with " ,stackProgName ," (you have '" ,versionString haveVersion ,"'): " ,intercalate ", " (map versionString prohibitedVersions) ,"."] show (BadDockerVersionException requiredRange haveVersion) = concat ["The version of 'docker' you are using (" ,show haveVersion ,") is outside the required\n" ,"version range specified in stack.yaml (" ,T.unpack (versionRangeText requiredRange) ,")."] show InvalidVersionOutputException = "Cannot get Docker version (invalid 'docker --version' output)." show (HostStackTooOldException minVersion (Just hostVersion)) = concat ["The host's version of '" ,stackProgName ,"' is too old for this Docker image.\nVersion " ,versionString minVersion ," is required; you have " ,versionString hostVersion ,"."] show (HostStackTooOldException minVersion Nothing) = concat ["The host's version of '" ,stackProgName ,"' is too old.\nVersion " ,versionString minVersion ," is required."] show (ContainerStackTooOldException requiredVersion containerVersion) = concat ["The Docker container's version of '" ,stackProgName ,"' is too old.\nVersion " ,versionString requiredVersion ," is required; the container has " ,versionString containerVersion ,"."] show CannotDetermineProjectRootException = "Cannot determine project root directory for Docker sandbox." show DockerNotInstalledException = "Cannot find 'docker' in PATH. Is Docker installed?" show UnsupportedStackExeHostPlatformException = concat [ "Using host's " , stackProgName , " executable in Docker container is only supported on " , display dockerContainerPlatform , " platform" ] show (DockerStackExeParseException s) = concat [ "Failed to parse " , show s , ". Expected " , show dockerStackExeDownloadVal , ", " , show dockerStackExeHostVal , ", " , show dockerStackExeImageVal , " or absolute path to executable." ] -- | Docker enable argument name. dockerEnableArgName :: Text dockerEnableArgName = "enable" -- | Docker repo arg argument name. dockerRepoArgName :: Text dockerRepoArgName = "repo" -- | Docker image argument name. dockerImageArgName :: Text dockerImageArgName = "image" -- | Docker registry login argument name. dockerRegistryLoginArgName :: Text dockerRegistryLoginArgName = "registry-login" -- | Docker registry username argument name. dockerRegistryUsernameArgName :: Text dockerRegistryUsernameArgName = "registry-username" -- | Docker registry password argument name. dockerRegistryPasswordArgName :: Text dockerRegistryPasswordArgName = "registry-password" -- | Docker auto-pull argument name. dockerAutoPullArgName :: Text dockerAutoPullArgName = "auto-pull" -- | Docker detach argument name. dockerDetachArgName :: Text dockerDetachArgName = "detach" -- | Docker run args argument name. dockerRunArgsArgName :: Text dockerRunArgsArgName = "run-args" -- | Docker mount argument name. dockerMountArgName :: Text dockerMountArgName = "mount" -- | Docker environment variable argument name. dockerEnvArgName :: Text dockerEnvArgName = "env" -- | Docker container name argument name. dockerContainerNameArgName :: Text dockerContainerNameArgName = "container-name" -- | Docker persist argument name. dockerPersistArgName :: Text dockerPersistArgName = "persist" -- | Docker database path argument name. dockerDatabasePathArgName :: Text dockerDatabasePathArgName = "database-path" -- | Docker database path argument name. dockerStackExeArgName :: Text dockerStackExeArgName = "stack-exe" -- | Value for @--docker-stack-exe=download@ dockerStackExeDownloadVal :: String dockerStackExeDownloadVal = "download" -- | Value for @--docker-stack-exe=host@ dockerStackExeHostVal :: String dockerStackExeHostVal = "host" -- | Value for @--docker-stack-exe=image@ dockerStackExeImageVal :: String dockerStackExeImageVal = "image" -- | Docker @set-user@ argument name dockerSetUserArgName :: Text dockerSetUserArgName = "set-user" -- | Docker @require-version@ argument name dockerRequireDockerVersionArgName :: Text dockerRequireDockerVersionArgName = "require-docker-version" -- | Argument name used to pass docker entrypoint data (only used internally) dockerEntrypointArgName :: String dockerEntrypointArgName = "internal-docker-entrypoint" -- | Command-line argument for "docker" dockerCmdName :: String dockerCmdName = "docker" dockerHelpOptName :: String dockerHelpOptName = dockerCmdName ++ "-help" -- | Command-line argument for @docker pull@. dockerPullCmdName :: String dockerPullCmdName = "pull" -- | Command-line argument for @docker cleanup@. dockerCleanupCmdName :: String dockerCleanupCmdName = "cleanup" -- | Command-line option for @--internal-re-exec-version@. reExecArgName :: String reExecArgName = "internal-re-exec-version" -- | Platform that Docker containers run dockerContainerPlatform :: Platform dockerContainerPlatform = Platform X86_64 Linux stack-1.9.3.1/src/Stack/Types/FlagName.hs0000644000000000000000000000661413455617610016143 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude #-} {-# LANGUAGE BangPatterns #-} {-# LANGUAGE TemplateHaskell #-} {-# LANGUAGE DeriveGeneric #-} {-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE GeneralizedNewtypeDeriving #-} {-# LANGUAGE DeriveDataTypeable #-} {-# LANGUAGE TupleSections #-} -- | Names for flags. module Stack.Types.FlagName (FlagName ,FlagNameParseFail(..) ,flagNameParser ,parseFlagName ,parseFlagNameFromString ,flagNameString ,flagNameText ,fromCabalFlagName ,toCabalFlagName ,mkFlagName) where import Stack.Prelude import Data.Aeson.Extended import Data.Attoparsec.Text as A import Data.Char (isLetter, isDigit, toLower) import qualified Data.Text as T import qualified Distribution.PackageDescription as Cabal import Language.Haskell.TH import Language.Haskell.TH.Syntax -- | A parse fail. newtype FlagNameParseFail = FlagNameParseFail Text deriving (Typeable) instance Exception FlagNameParseFail instance Show FlagNameParseFail where show (FlagNameParseFail bs) = "Invalid flag name: " ++ show bs -- | A flag name. newtype FlagName = FlagName Text deriving (Typeable,Data,Generic,Hashable,Store,NFData,ToJSONKey) instance Eq FlagName where x == y = compare x y == EQ instance Ord FlagName where compare (FlagName x) (FlagName y) = compare (T.map toLower x) (T.map toLower y) instance Lift FlagName where lift (FlagName n) = appE (conE 'FlagName) (stringE (T.unpack n)) instance Show FlagName where show (FlagName n) = T.unpack n instance FromJSON FlagName where parseJSON j = do s <- parseJSON j case parseFlagNameFromString s of Nothing -> fail ("Couldn't parse flag name: " ++ s) Just ver -> return ver instance FromJSONKey FlagName where fromJSONKey = FromJSONKeyTextParser $ \k -> either (fail . show) return $ parseFlagName k -- | Attoparsec parser for a flag name flagNameParser :: Parser FlagName flagNameParser = fmap FlagName $ do t <- A.takeWhile1 (\c -> isAlphaNum c || separator c) when (T.head t == '-') $ fail "flag name cannot start with dash" return t where separator c = c == '-' || c == '_' isAlphaNum c = isLetter c || isDigit c -- | Make a flag name. mkFlagName :: String -> Q Exp mkFlagName s = case parseFlagNameFromString s of Nothing -> qRunIO $ throwString ("Invalid flag name: " ++ show s) Just pn -> [|pn|] -- | Convenient way to parse a flag name from a 'Text'. parseFlagName :: MonadThrow m => Text -> m FlagName parseFlagName x = go x where go = either (const (throwM (FlagNameParseFail x))) return . parseOnly (flagNameParser <* endOfInput) -- | Convenience function for parsing from a 'String' parseFlagNameFromString :: MonadThrow m => String -> m FlagName parseFlagNameFromString = parseFlagName . T.pack -- | Produce a string representation of a flag name. flagNameString :: FlagName -> String flagNameString (FlagName n) = T.unpack n -- | Produce a string representation of a flag name. flagNameText :: FlagName -> Text flagNameText (FlagName n) = n -- | Convert from a Cabal flag name. fromCabalFlagName :: Cabal.FlagName -> FlagName fromCabalFlagName name = let !x = T.pack $ Cabal.unFlagName name in FlagName x -- | Convert to a Cabal flag name. toCabalFlagName :: FlagName -> Cabal.FlagName toCabalFlagName (FlagName name) = let !x = T.unpack name in Cabal.mkFlagName x stack-1.9.3.1/src/Stack/Types/GhcPkgId.hs0000644000000000000000000000325213455617610016104 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude #-} {-# LANGUAGE DeriveGeneric #-} {-# LANGUAGE DeriveDataTypeable #-} -- | A ghc-pkg id. module Stack.Types.GhcPkgId (GhcPkgId ,ghcPkgIdParser ,parseGhcPkgId ,ghcPkgIdString) where import Stack.Prelude import Data.Aeson.Extended import Data.Attoparsec.Text import qualified Data.Text as T -- | A parse fail. newtype GhcPkgIdParseFail = GhcPkgIdParseFail Text deriving Typeable instance Show GhcPkgIdParseFail where show (GhcPkgIdParseFail bs) = "Invalid package ID: " ++ show bs instance Exception GhcPkgIdParseFail -- | A ghc-pkg package identifier. newtype GhcPkgId = GhcPkgId Text deriving (Eq,Ord,Data,Typeable,Generic) instance Hashable GhcPkgId instance NFData GhcPkgId instance Store GhcPkgId instance Show GhcPkgId where show = show . ghcPkgIdString instance FromJSON GhcPkgId where parseJSON = withText "GhcPkgId" $ \t -> case parseGhcPkgId t of Left e -> fail $ show (e, t) Right x -> return x instance ToJSON GhcPkgId where toJSON g = toJSON (ghcPkgIdString g) -- | Convenient way to parse a package name from a 'Text'. parseGhcPkgId :: MonadThrow m => Text -> m GhcPkgId parseGhcPkgId x = go x where go = either (const (throwM (GhcPkgIdParseFail x))) return . parseOnly (ghcPkgIdParser <* endOfInput) -- | A parser for a package-version-hash pair. ghcPkgIdParser :: Parser GhcPkgId ghcPkgIdParser = let elements = "_.-" :: String in GhcPkgId . T.pack <$> many1 (choice [digit, letter, satisfy (`elem` elements)]) -- | Get a string representation of GHC package id. ghcPkgIdString :: GhcPkgId -> String ghcPkgIdString (GhcPkgId x) = T.unpack x stack-1.9.3.1/src/Stack/Types/Image.hs0000644000000000000000000000651213455617610015510 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude #-} {-# LANGUAGE DeriveGeneric #-} {-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE RecordWildCards #-} {-# LANGUAGE ScopedTypeVariables #-} module Stack.Types.Image where import Data.Aeson.Extended import qualified Data.Map as Map import Generics.Deriving.Monoid (mappenddefault, memptydefault) import Path import Stack.Prelude -- | Image options. Currently only Docker image options. newtype ImageOpts = ImageOpts { imgDockers :: [ImageDockerOpts] -- ^ One or more stanzas for docker image settings. } deriving (Show) data ImageDockerOpts = ImageDockerOpts { imgDockerBase :: !(Maybe String) -- ^ Maybe have a docker base image name. (Although we will not -- be able to create any Docker images without this.) , imgDockerEntrypoints :: !(Maybe [String]) -- ^ Maybe have a specific ENTRYPOINT list that will be used to -- create images. , imgDockerAdd :: !(Map FilePath (Path Abs Dir)) -- ^ Maybe have some static project content to include in a -- specific directory in all the images. , imgDockerImageName :: !(Maybe String) -- ^ Maybe have a name for the image we are creating , imgDockerExecutables :: !(Maybe [Path Rel File]) -- ^ Filenames of executables to add (if Nothing, add them all) } deriving (Show) newtype ImageOptsMonoid = ImageOptsMonoid { imgMonoidDockers :: [ImageDockerOpts] } deriving (Show, Generic) instance FromJSON (WithJSONWarnings ImageOptsMonoid) where parseJSON = withObjectWarnings "ImageOptsMonoid" (\o -> do (oldDocker :: Maybe ImageDockerOpts) <- jsonSubWarningsT (o ..:? imgDockerOldArgName) (dockers :: [ImageDockerOpts]) <- jsonSubWarningsT (o ..:? imgDockersArgName ..!= []) let imgMonoidDockers = dockers ++ maybeToList oldDocker return ImageOptsMonoid { .. }) instance Semigroup ImageOptsMonoid where (<>) = mappenddefault instance Monoid ImageOptsMonoid where mempty = memptydefault mappend = (<>) instance FromJSON (WithJSONWarnings ImageDockerOpts) where parseJSON = withObjectWarnings "ImageDockerOpts" (\o -> do imgDockerBase <- o ..:? imgDockerBaseArgName imgDockerEntrypoints <- o ..:? imgDockerEntrypointsArgName imgDockerAdd <- o ..:? imgDockerAddArgName ..!= Map.empty imgDockerImageName <- o ..:? imgDockerImageNameArgName imgDockerExecutables <- o ..:? imgDockerExecutablesArgName return ImageDockerOpts { .. }) imgArgName :: Text imgArgName = "image" -- Kept for backward compatibility imgDockerOldArgName :: Text imgDockerOldArgName = "container" imgDockersArgName :: Text imgDockersArgName = "containers" imgDockerBaseArgName :: Text imgDockerBaseArgName = "base" imgDockerAddArgName :: Text imgDockerAddArgName = "add" imgDockerEntrypointsArgName :: Text imgDockerEntrypointsArgName = "entrypoints" imgDockerImageNameArgName :: Text imgDockerImageNameArgName = "name" imgDockerExecutablesArgName :: Text imgDockerExecutablesArgName = "executables" stack-1.9.3.1/src/Stack/Types/NamedComponent.hs0000644000000000000000000000450713455617610017377 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude #-} {-# LANGUAGE OverloadedStrings #-} module Stack.Types.NamedComponent ( NamedComponent (..) , renderComponent , renderPkgComponents , renderPkgComponent , exeComponents , testComponents , benchComponents , internalLibComponents , isCLib , isCInternalLib , isCExe , isCTest , isCBench ) where import Stack.Prelude import Stack.Types.PackageName import qualified Data.Set as Set import qualified Data.Text as T -- | A single, fully resolved component of a package data NamedComponent = CLib | CInternalLib !Text | CExe !Text | CTest !Text | CBench !Text deriving (Show, Eq, Ord) renderComponent :: NamedComponent -> Text renderComponent CLib = "lib" renderComponent (CInternalLib x) = "internal-lib:" <> x renderComponent (CExe x) = "exe:" <> x renderComponent (CTest x) = "test:" <> x renderComponent (CBench x) = "bench:" <> x renderPkgComponents :: [(PackageName, NamedComponent)] -> Text renderPkgComponents = T.intercalate " " . map renderPkgComponent renderPkgComponent :: (PackageName, NamedComponent) -> Text renderPkgComponent (pkg, comp) = packageNameText pkg <> ":" <> renderComponent comp exeComponents :: Set NamedComponent -> Set Text exeComponents = Set.fromList . mapMaybe mExeName . Set.toList where mExeName (CExe name) = Just name mExeName _ = Nothing testComponents :: Set NamedComponent -> Set Text testComponents = Set.fromList . mapMaybe mTestName . Set.toList where mTestName (CTest name) = Just name mTestName _ = Nothing benchComponents :: Set NamedComponent -> Set Text benchComponents = Set.fromList . mapMaybe mBenchName . Set.toList where mBenchName (CBench name) = Just name mBenchName _ = Nothing internalLibComponents :: Set NamedComponent -> Set Text internalLibComponents = Set.fromList . mapMaybe mInternalName . Set.toList where mInternalName (CInternalLib name) = Just name mInternalName _ = Nothing isCLib :: NamedComponent -> Bool isCLib CLib{} = True isCLib _ = False isCInternalLib :: NamedComponent -> Bool isCInternalLib CInternalLib{} = True isCInternalLib _ = False isCExe :: NamedComponent -> Bool isCExe CExe{} = True isCExe _ = False isCTest :: NamedComponent -> Bool isCTest CTest{} = True isCTest _ = False isCBench :: NamedComponent -> Bool isCBench CBench{} = True isCBench _ = False stack-1.9.3.1/src/Stack/Types/Nix.hs0000644000000000000000000000666613455617610015236 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude #-} {-# LANGUAGE DeriveGeneric #-} {-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE RecordWildCards #-} -- | Nix types. module Stack.Types.Nix where import Data.Aeson.Extended import Stack.Prelude import Generics.Deriving.Monoid (mappenddefault, memptydefault) -- | Nix configuration. Parameterize by resolver type to avoid cyclic -- dependency. data NixOpts = NixOpts {nixEnable :: !Bool ,nixPureShell :: !Bool ,nixPackages :: ![Text] -- ^ The system packages to be installed in the environment before it runs ,nixInitFile :: !(Maybe FilePath) -- ^ The path of a file containing preconfiguration of the environment (e.g shell.nix) ,nixShellOptions :: ![Text] -- ^ Options to be given to the nix-shell command line ,nixAddGCRoots :: !Bool -- ^ Should we register gc roots so running nix-collect-garbage doesn't remove nix dependencies } deriving (Show) -- | An uninterpreted representation of nix options. -- Configurations may be "cascaded" using mappend (left-biased). data NixOptsMonoid = NixOptsMonoid {nixMonoidEnable :: !(First Bool) -- ^ Is using nix-shell enabled? ,nixMonoidPureShell :: !(First Bool) -- ^ Should the nix-shell be pure ,nixMonoidPackages :: !(First [Text]) -- ^ System packages to use (given to nix-shell) ,nixMonoidInitFile :: !(First FilePath) -- ^ The path of a file containing preconfiguration of the environment (e.g shell.nix) ,nixMonoidShellOptions :: !(First [Text]) -- ^ Options to be given to the nix-shell command line ,nixMonoidPath :: !(First [Text]) -- ^ Override parts of NIX_PATH (notably 'nixpkgs') ,nixMonoidAddGCRoots :: !(First Bool) -- ^ Should we register gc roots so running nix-collect-garbage doesn't remove nix dependencies } deriving (Eq, Show, Generic) -- | Decode uninterpreted nix options from JSON/YAML. instance FromJSON (WithJSONWarnings NixOptsMonoid) where parseJSON = withObjectWarnings "NixOptsMonoid" (\o -> do nixMonoidEnable <- First <$> o ..:? nixEnableArgName nixMonoidPureShell <- First <$> o ..:? nixPureShellArgName nixMonoidPackages <- First <$> o ..:? nixPackagesArgName nixMonoidInitFile <- First <$> o ..:? nixInitFileArgName nixMonoidShellOptions <- First <$> o ..:? nixShellOptsArgName nixMonoidPath <- First <$> o ..:? nixPathArgName nixMonoidAddGCRoots <- First <$> o ..:? nixAddGCRootsArgName return NixOptsMonoid{..}) -- | Left-biased combine Nix options instance Semigroup NixOptsMonoid where (<>) = mappenddefault -- | Left-biased combine Nix options instance Monoid NixOptsMonoid where mempty = memptydefault mappend = (<>) -- | Nix enable argument name. nixEnableArgName :: Text nixEnableArgName = "enable" -- | Nix run in pure shell argument name. nixPureShellArgName :: Text nixPureShellArgName = "pure" -- | Nix packages (build inputs) argument name. nixPackagesArgName :: Text nixPackagesArgName = "packages" -- | shell.nix file path argument name. nixInitFileArgName :: Text nixInitFileArgName = "shell-file" -- | Extra options for the nix-shell command argument name. nixShellOptsArgName :: Text nixShellOptsArgName = "nix-shell-options" -- | NIX_PATH override argument name nixPathArgName :: Text nixPathArgName = "path" -- | Add GC roots arg name nixAddGCRootsArgName :: Text nixAddGCRootsArgName = "add-gc-roots" stack-1.9.3.1/src/Stack/Types/Package.hs0000644000000000000000000004061013455617610016016 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude #-} {-# LANGUAGE GeneralizedNewtypeDeriving #-} {-# LANGUAGE DeriveGeneric #-} {-# LANGUAGE DeriveDataTypeable #-} {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE RankNTypes #-} {-# LANGUAGE FlexibleContexts #-} {-# LANGUAGE DataKinds #-} {-# LANGUAGE ConstraintKinds #-} module Stack.Types.Package where import Stack.Prelude import qualified Data.ByteString as S import Data.List import qualified Data.Map as M import qualified Data.Set as Set import Data.Store.Version (VersionConfig) import Data.Store.VersionTagged (storeVersionConfig) import Distribution.Parsec.Common (PError (..), PWarning (..), showPos) import qualified Distribution.SPDX.License as SPDX import Distribution.License (License) import Distribution.ModuleName (ModuleName) import Distribution.PackageDescription (TestSuiteInterface, BuildType) import Distribution.System (Platform (..)) import Path as FL import Stack.Types.BuildPlan (PackageLocation, PackageLocationIndex (..), ExeName) import Stack.Types.Compiler import Stack.Types.Config import Stack.Types.FlagName import Stack.Types.GhcPkgId import Stack.Types.NamedComponent import Stack.Types.PackageIdentifier import Stack.Types.PackageName import Stack.Types.Version -- | All exceptions thrown by the library. data PackageException = PackageInvalidCabalFile !(Either PackageIdentifierRevision (Path Abs File)) !(Maybe Version) ![PError] ![PWarning] | PackageNoCabalFileFound (Path Abs Dir) | PackageMultipleCabalFilesFound (Path Abs Dir) [Path Abs File] | MismatchedCabalName (Path Abs File) PackageName | MismatchedCabalIdentifier !PackageIdentifierRevision !PackageIdentifier deriving Typeable instance Exception PackageException instance Show PackageException where show (PackageInvalidCabalFile loc _mversion errs warnings) = concat [ "Unable to parse cabal file " , case loc of Left pir -> "for " ++ packageIdentifierRevisionString pir Right fp -> toFilePath fp {- Not actually needed, the errors will indicate if a newer version exists. Also, it seems that this is set to Just the version even if we support it. , case mversion of Nothing -> "" Just version -> "\nRequires newer Cabal file parser version: " ++ versionString version -} , "\n\n" , unlines $ map (\(PError pos msg) -> concat [ "- " , showPos pos , ": " , msg ]) errs , unlines $ map (\(PWarning _ pos msg) -> concat [ "- " , showPos pos , ": " , msg ]) warnings ] show (PackageNoCabalFileFound dir) = concat [ "Stack looks for packages in the directories configured in" , " the 'packages' and 'extra-deps' fields defined in your stack.yaml\n" , "The current entry points to " , toFilePath dir , " but no .cabal or package.yaml file could be found there." ] show (PackageMultipleCabalFilesFound dir files) = "Multiple .cabal files found in directory " ++ toFilePath dir ++ ": " ++ intercalate ", " (map (toFilePath . filename) files) show (MismatchedCabalName fp name) = concat [ "cabal file path " , toFilePath fp , " does not match the package name it defines.\n" , "Please rename the file to: " , packageNameString name , ".cabal\n" , "For more information, see: https://github.com/commercialhaskell/stack/issues/317" ] show (MismatchedCabalIdentifier pir ident) = concat [ "Mismatched package identifier." , "\nFound: " , packageIdentifierString ident , "\nExpected: " , packageIdentifierRevisionString pir ] -- | Libraries in a package. Since Cabal 2.0, internal libraries are a -- thing. data PackageLibraries = NoLibraries | HasLibraries !(Set Text) -- ^ the foreign library names, sub libraries get built automatically without explicit component name passing deriving (Show,Typeable) -- | Some package info. data Package = Package {packageName :: !PackageName -- ^ Name of the package. ,packageVersion :: !Version -- ^ Version of the package ,packageLicense :: !(Either SPDX.License License) -- ^ The license the package was released under. ,packageFiles :: !GetPackageFiles -- ^ Get all files of the package. ,packageDeps :: !(Map PackageName DepValue) -- ^ Packages that the package depends on, both as libraries and build tools. ,packageUnknownTools :: !(Set ExeName) -- ^ Build tools specified in the legacy manner (build-tools:) that failed the hard-coded lookup. ,packageAllDeps :: !(Set PackageName) -- ^ Original dependencies (not sieved). ,packageGhcOptions :: ![Text] -- ^ Ghc options used on package. ,packageFlags :: !(Map FlagName Bool) -- ^ Flags used on package. ,packageDefaultFlags :: !(Map FlagName Bool) -- ^ Defaults for unspecified flags. ,packageLibraries :: !PackageLibraries -- ^ does the package have a buildable library stanza? ,packageInternalLibraries :: !(Set Text) -- ^ names of internal libraries ,packageTests :: !(Map Text TestSuiteInterface) -- ^ names and interfaces of test suites ,packageBenchmarks :: !(Set Text) -- ^ names of benchmarks ,packageExes :: !(Set Text) -- ^ names of executables ,packageOpts :: !GetPackageOpts -- ^ Args to pass to GHC. ,packageHasExposedModules :: !Bool -- ^ Does the package have exposed modules? ,packageBuildType :: !BuildType -- ^ Package build-type. ,packageSetupDeps :: !(Maybe (Map PackageName VersionRange)) -- ^ If present: custom-setup dependencies } deriving (Show,Typeable) -- | The value for a map from dependency name. This contains both the -- version range and the type of dependency, and provides a semigroup -- instance. data DepValue = DepValue { dvVersionRange :: !VersionRange , dvType :: !DepType } deriving (Show,Typeable) instance Semigroup DepValue where DepValue a x <> DepValue b y = DepValue (intersectVersionRanges a b) (x <> y) -- | Is this package being used as a library, or just as a build tool? -- If the former, we need to ensure that a library actually -- exists. See -- data DepType = AsLibrary | AsBuildTool deriving (Show, Eq) instance Semigroup DepType where AsLibrary <> _ = AsLibrary AsBuildTool <> x = x packageIdentifier :: Package -> PackageIdentifier packageIdentifier pkg = PackageIdentifier (packageName pkg) (packageVersion pkg) packageDefinedFlags :: Package -> Set FlagName packageDefinedFlags = M.keysSet . packageDefaultFlags -- | Files that the package depends on, relative to package directory. -- Argument is the location of the .cabal file newtype GetPackageOpts = GetPackageOpts { getPackageOpts :: forall env. HasEnvConfig env => SourceMap -> InstalledMap -> [PackageName] -> [PackageName] -> Path Abs File -> RIO env (Map NamedComponent (Map ModuleName (Path Abs File)) ,Map NamedComponent (Set DotCabalPath) ,Map NamedComponent BuildInfoOpts) } instance Show GetPackageOpts where show _ = "" -- | GHC options based on cabal information and ghc-options. data BuildInfoOpts = BuildInfoOpts { bioOpts :: [String] , bioOneWordOpts :: [String] , bioPackageFlags :: [String] -- ^ These options can safely have 'nubOrd' applied to them, as -- there are no multi-word options (see -- https://github.com/commercialhaskell/stack/issues/1255) , bioCabalMacros :: Path Abs File } deriving Show -- | Files to get for a cabal package. data CabalFileType = AllFiles | Modules -- | Files that the package depends on, relative to package directory. -- Argument is the location of the .cabal file newtype GetPackageFiles = GetPackageFiles { getPackageFiles :: forall env. HasEnvConfig env => Path Abs File -> RIO env (Map NamedComponent (Map ModuleName (Path Abs File)) ,Map NamedComponent (Set DotCabalPath) ,Set (Path Abs File) ,[PackageWarning]) } instance Show GetPackageFiles where show _ = "" -- | Warning generated when reading a package data PackageWarning = UnlistedModulesWarning NamedComponent [ModuleName] -- ^ Modules found that are not listed in cabal file -- TODO: bring this back - see -- https://github.com/commercialhaskell/stack/issues/2649 {- | MissingModulesWarning (Path Abs File) (Maybe String) [ModuleName] -- ^ Modules not found in file system, which are listed in cabal file -} -- | Package build configuration data PackageConfig = PackageConfig {packageConfigEnableTests :: !Bool -- ^ Are tests enabled? ,packageConfigEnableBenchmarks :: !Bool -- ^ Are benchmarks enabled? ,packageConfigFlags :: !(Map FlagName Bool) -- ^ Configured flags. ,packageConfigGhcOptions :: ![Text] -- ^ Configured ghc options. ,packageConfigCompilerVersion :: !(CompilerVersion 'CVActual) -- ^ GHC version ,packageConfigPlatform :: !Platform -- ^ host platform } deriving (Show,Typeable) -- | Compares the package name. instance Ord Package where compare = on compare packageName -- | Compares the package name. instance Eq Package where (==) = on (==) packageName type SourceMap = Map PackageName PackageSource -- | Where the package's source is located: local directory or package index data PackageSource = PSFiles LocalPackage InstallLocation -- ^ Package which exist on the filesystem (as opposed to an index tarball) | PSIndex InstallLocation (Map FlagName Bool) [Text] PackageIdentifierRevision -- ^ Package which is in an index, and the files do not exist on the -- filesystem yet. deriving Show piiVersion :: PackageSource -> Version piiVersion (PSFiles lp _) = packageVersion $ lpPackage lp piiVersion (PSIndex _ _ _ (PackageIdentifierRevision (PackageIdentifier _ v) _)) = v piiLocation :: PackageSource -> InstallLocation piiLocation (PSFiles _ loc) = loc piiLocation (PSIndex loc _ _ _) = loc piiPackageLocation :: PackageSource -> PackageLocationIndex FilePath piiPackageLocation (PSFiles lp _) = PLOther (lpLocation lp) piiPackageLocation (PSIndex _ _ _ pir) = PLIndex pir -- | Information on a locally available package of source code data LocalPackage = LocalPackage { lpPackage :: !Package -- ^ The @Package@ info itself, after resolution with package flags, -- with tests and benchmarks disabled , lpComponents :: !(Set NamedComponent) -- ^ Components to build, not including the library component. , lpUnbuildable :: !(Set NamedComponent) -- ^ Components explicitly requested for build, that are marked -- "buildable: false". , lpWanted :: !Bool -- FIXME Should completely drop this "wanted" terminology, it's unclear -- ^ Whether this package is wanted as a target. , lpTestDeps :: !(Map PackageName VersionRange) -- ^ Used for determining if we can use --enable-tests in a normal build. , lpBenchDeps :: !(Map PackageName VersionRange) -- ^ Used for determining if we can use --enable-benchmarks in a normal -- build. , lpTestBench :: !(Maybe Package) -- ^ This stores the 'Package' with tests and benchmarks enabled, if -- either is asked for by the user. , lpDir :: !(Path Abs Dir) -- ^ Directory of the package. , lpCabalFile :: !(Path Abs File) -- ^ The .cabal file , lpForceDirty :: !Bool , lpDirtyFiles :: !(Maybe (Set FilePath)) -- ^ Nothing == not dirty, Just == dirty. Note that the Set may be empty if -- we forced the build to treat packages as dirty. Also, the Set may not -- include all modified files. , lpNewBuildCaches :: !(Map NamedComponent (Map FilePath FileCacheInfo)) -- ^ current state of the files , lpComponentFiles :: !(Map NamedComponent (Set (Path Abs File))) -- ^ all files used by this package , lpLocation :: !(PackageLocation FilePath) -- ^ Where this source code came from } deriving Show lpFiles :: LocalPackage -> Set.Set (Path Abs File) lpFiles = Set.unions . M.elems . lpComponentFiles -- | A location to install a package into, either snapshot or local data InstallLocation = Snap | Local deriving (Show, Eq) instance Semigroup InstallLocation where Local <> _ = Local _ <> Local = Local Snap <> Snap = Snap instance Monoid InstallLocation where mempty = Snap mappend = (<>) data InstalledPackageLocation = InstalledTo InstallLocation | ExtraGlobal deriving (Show, Eq) data FileCacheInfo = FileCacheInfo { fciModTime :: !ModTime , fciSize :: !Word64 , fciHash :: !S.ByteString } deriving (Generic, Show, Eq, Data, Typeable) instance Store FileCacheInfo instance NFData FileCacheInfo -- | Used for storage and comparison. newtype ModTime = ModTime (Integer,Rational) deriving (Ord, Show, Generic, Eq, NFData, Store, Data, Typeable) modTimeVC :: VersionConfig ModTime modTimeVC = storeVersionConfig "mod-time-v1" "UBECpUI0JvM_SBOnRNdaiF9_yOU=" testSuccessVC :: VersionConfig Bool testSuccessVC = storeVersionConfig "test-v1" "jC_GB0SGtbpRQbDlm7oQJP7thu8=" -- | A descriptor from a .cabal file indicating one of the following: -- -- exposed-modules: Foo -- other-modules: Foo -- or -- main-is: Foo.hs -- data DotCabalDescriptor = DotCabalModule !ModuleName | DotCabalMain !FilePath | DotCabalFile !FilePath | DotCabalCFile !FilePath deriving (Eq,Ord,Show) -- | Maybe get the module name from the .cabal descriptor. dotCabalModule :: DotCabalDescriptor -> Maybe ModuleName dotCabalModule (DotCabalModule m) = Just m dotCabalModule _ = Nothing -- | Maybe get the main name from the .cabal descriptor. dotCabalMain :: DotCabalDescriptor -> Maybe FilePath dotCabalMain (DotCabalMain m) = Just m dotCabalMain _ = Nothing -- | A path resolved from the .cabal file, which is either main-is or -- an exposed/internal/referenced module. data DotCabalPath = DotCabalModulePath !(Path Abs File) | DotCabalMainPath !(Path Abs File) | DotCabalFilePath !(Path Abs File) | DotCabalCFilePath !(Path Abs File) deriving (Eq,Ord,Show) -- | Get the module path. dotCabalModulePath :: DotCabalPath -> Maybe (Path Abs File) dotCabalModulePath (DotCabalModulePath fp) = Just fp dotCabalModulePath _ = Nothing -- | Get the main path. dotCabalMainPath :: DotCabalPath -> Maybe (Path Abs File) dotCabalMainPath (DotCabalMainPath fp) = Just fp dotCabalMainPath _ = Nothing -- | Get the c file path. dotCabalCFilePath :: DotCabalPath -> Maybe (Path Abs File) dotCabalCFilePath (DotCabalCFilePath fp) = Just fp dotCabalCFilePath _ = Nothing -- | Get the path. dotCabalGetPath :: DotCabalPath -> Path Abs File dotCabalGetPath dcp = case dcp of DotCabalModulePath fp -> fp DotCabalMainPath fp -> fp DotCabalFilePath fp -> fp DotCabalCFilePath fp -> fp type InstalledMap = Map PackageName (InstallLocation, Installed) data Installed = Library PackageIdentifier GhcPkgId (Maybe (Either SPDX.License License)) | Executable PackageIdentifier deriving (Show, Eq) installedPackageIdentifier :: Installed -> PackageIdentifier installedPackageIdentifier (Library pid _ _) = pid installedPackageIdentifier (Executable pid) = pid -- | Get the installed Version. installedVersion :: Installed -> Version installedVersion = packageIdentifierVersion . installedPackageIdentifier stack-1.9.3.1/src/Stack/Types/PackageDump.hs0000644000000000000000000000236513455617610016651 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude #-} {-# LANGUAGE DeriveDataTypeable #-} {-# LANGUAGE DeriveGeneric #-} {-# LANGUAGE GeneralizedNewtypeDeriving #-} module Stack.Types.PackageDump ( InstalledCache(..) , InstalledCacheInner(..) , InstalledCacheEntry(..) , installedCacheVC ) where import Data.Store import Data.Store.Version import Data.Store.VersionTagged import Stack.Prelude import Stack.Types.GhcPkgId import Stack.Types.PackageIdentifier -- | Cached information on whether package have profiling libraries and haddocks. newtype InstalledCache = InstalledCache (IORef InstalledCacheInner) newtype InstalledCacheInner = InstalledCacheInner (Map GhcPkgId InstalledCacheEntry) deriving (Store, Generic, Eq, Show, Data, Typeable) -- | Cached information on whether a package has profiling libraries and haddocks. data InstalledCacheEntry = InstalledCacheEntry { installedCacheProfiling :: !Bool , installedCacheHaddock :: !Bool , installedCacheSymbols :: !Bool , installedCacheIdent :: !PackageIdentifier } deriving (Eq, Generic, Show, Data, Typeable) instance Store InstalledCacheEntry installedCacheVC :: VersionConfig InstalledCacheInner installedCacheVC = storeVersionConfig "installed-v1" "GGyaE6qY9FOqeWtozuadKqS7_QM=" stack-1.9.3.1/src/Stack/Types/PackageIdentifier.hs0000644000000000000000000002415513455617610020027 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude #-} {-# LANGUAGE BangPatterns #-} {-# LANGUAGE DataKinds #-} {-# LANGUAGE DeriveDataTypeable #-} {-# LANGUAGE DeriveGeneric #-} {-# LANGUAGE GeneralizedNewtypeDeriving #-} {-# LANGUAGE ScopedTypeVariables #-} {-# OPTIONS -fno-warn-unused-do-bind #-} -- | Package identifier (name-version). module Stack.Types.PackageIdentifier ( PackageIdentifier(..) , PackageIdentifierRevision(..) , CabalHash , mkCabalHashFromSHA256 , computeCabalHash , showCabalHash , CabalFileInfo(..) , toTuple , fromTuple , parsePackageIdentifier , parsePackageIdentifierFromString , parsePackageIdentifierRevision , packageIdentifierParser , packageIdentifierString , packageIdentifierRevisionString , packageIdentifierText , toCabalPackageIdentifier , fromCabalPackageIdentifier , StaticSHA256 , mkStaticSHA256FromText , mkStaticSHA256FromFile , mkStaticSHA256FromDigest , staticSHA256ToText , staticSHA256ToBase16 , staticSHA256ToRaw ) where import Stack.Prelude import Crypto.Hash.Conduit (hashFile) import Crypto.Hash as Hash (hashlazy, Digest, SHA256) import Data.Aeson.Extended import Data.Attoparsec.Text as A import qualified Data.ByteArray import qualified Data.ByteArray.Encoding as Mem import qualified Data.ByteString.Lazy as L import qualified Data.Text as T import Data.Text.Encoding (decodeUtf8, encodeUtf8) import qualified Distribution.Package as C import Stack.StaticBytes import Stack.Types.PackageName import Stack.Types.Version -- | A parse fail. data PackageIdentifierParseFail = PackageIdentifierParseFail Text | PackageIdentifierRevisionParseFail Text deriving (Typeable) instance Show PackageIdentifierParseFail where show (PackageIdentifierParseFail bs) = "Invalid package identifier: " ++ show bs show (PackageIdentifierRevisionParseFail bs) = "Invalid package identifier (with optional revision): " ++ show bs instance Exception PackageIdentifierParseFail -- | A pkg-ver combination. data PackageIdentifier = PackageIdentifier { -- | Get the name part of the identifier. packageIdentifierName :: !PackageName -- | Get the version part of the identifier. , packageIdentifierVersion :: !Version } deriving (Eq,Ord,Generic,Data,Typeable) instance NFData PackageIdentifier where rnf (PackageIdentifier !p !v) = seq (rnf p) (rnf v) instance Hashable PackageIdentifier instance Store PackageIdentifier instance Show PackageIdentifier where show = show . packageIdentifierString instance Display PackageIdentifier where display = fromString . packageIdentifierString instance ToJSON PackageIdentifier where toJSON = toJSON . packageIdentifierString instance FromJSON PackageIdentifier where parseJSON = withText "PackageIdentifier" $ \t -> case parsePackageIdentifier t of Left e -> fail $ show (e, t) Right x -> return x -- | A 'PackageIdentifier' combined with optionally specified Hackage -- cabal file revision. data PackageIdentifierRevision = PackageIdentifierRevision { pirIdent :: !PackageIdentifier , pirRevision :: !CabalFileInfo } deriving (Eq,Ord,Generic,Data,Typeable) instance NFData PackageIdentifierRevision where rnf (PackageIdentifierRevision !i !c) = seq (rnf i) (rnf c) instance Hashable PackageIdentifierRevision instance Store PackageIdentifierRevision instance Show PackageIdentifierRevision where show = show . packageIdentifierRevisionString instance ToJSON PackageIdentifierRevision where toJSON = toJSON . packageIdentifierRevisionString instance FromJSON PackageIdentifierRevision where parseJSON = withText "PackageIdentifierRevision" $ \t -> case parsePackageIdentifierRevision t of Left e -> fail $ show (e, t) Right x -> return x -- | A cryptographic hash of a Cabal file. newtype CabalHash = CabalHash { unCabalHash :: StaticSHA256 } deriving (Generic, Show, Eq, NFData, Data, Typeable, Ord, Store, Hashable) -- | A SHA256 hash, stored in a static size for more efficient -- serialization with store. newtype StaticSHA256 = StaticSHA256 Bytes32 deriving (Generic, Show, Eq, NFData, Data, Typeable, Ord, Hashable, Store) -- | Generate a 'StaticSHA256' value from a base16-encoded SHA256 hash. mkStaticSHA256FromText :: Text -> Either SomeException StaticSHA256 mkStaticSHA256FromText t = mapLeft (toException . stringException) (Mem.convertFromBase Mem.Base16 (encodeUtf8 t)) >>= either (Left . toE) (Right . StaticSHA256) . toStaticExact . (id :: ByteString -> ByteString) where toE e = toException $ stringException $ concat [ "Unable to convert " , show t , " into SHA256: " , show e ] -- | Generate a 'StaticSHA256' value from the contents of a file. mkStaticSHA256FromFile :: MonadIO m => Path Abs File -> m StaticSHA256 mkStaticSHA256FromFile fp = liftIO $ mkStaticSHA256FromDigest <$> hashFile (toFilePath fp) mkStaticSHA256FromDigest :: Hash.Digest Hash.SHA256 -> StaticSHA256 mkStaticSHA256FromDigest digest = StaticSHA256 $ either impureThrow id $ toStaticExact (Data.ByteArray.convert digest :: ByteString) -- | Convert a 'StaticSHA256' into a base16-encoded SHA256 hash. staticSHA256ToText :: StaticSHA256 -> Text staticSHA256ToText = decodeUtf8 . staticSHA256ToBase16 -- | Convert a 'StaticSHA256' into a base16-encoded SHA256 hash. staticSHA256ToBase16 :: StaticSHA256 -> ByteString staticSHA256ToBase16 (StaticSHA256 x) = Mem.convertToBase Mem.Base16 x staticSHA256ToRaw :: StaticSHA256 -> ByteString staticSHA256ToRaw (StaticSHA256 x) = Data.ByteArray.convert x -- | Generate a 'CabalHash' value from a base16-encoded SHA256 hash. mkCabalHashFromSHA256 :: Text -> Either SomeException CabalHash mkCabalHashFromSHA256 = fmap CabalHash . mkStaticSHA256FromText -- | Convert a 'CabalHash' into a base16-encoded SHA256 hash. cabalHashToText :: CabalHash -> Text cabalHashToText = staticSHA256ToText . unCabalHash -- | Compute a 'CabalHash' value from a cabal file's contents. computeCabalHash :: L.ByteString -> CabalHash computeCabalHash = CabalHash . mkStaticSHA256FromDigest . Hash.hashlazy showCabalHash :: CabalHash -> Text showCabalHash = T.append (T.pack "sha256:") . cabalHashToText -- | Information on the contents of a cabal file data CabalFileInfo = CFILatest -- ^ Take the latest revision of the cabal file available. This -- isn't reproducible at all, but the running assumption (not -- necessarily true) is that cabal file revisions do not change -- semantics of the build. | CFIHash !(Maybe Int) -- file size in bytes !CabalHash -- ^ Identify by contents of the cabal file itself | CFIRevision !Word -- ^ Identify by revision number, with 0 being the original and -- counting upward. deriving (Generic, Show, Eq, Ord, Data, Typeable) instance Store CabalFileInfo instance NFData CabalFileInfo instance Hashable CabalFileInfo -- | Convert from a package identifier to a tuple. toTuple :: PackageIdentifier -> (PackageName,Version) toTuple (PackageIdentifier n v) = (n,v) -- | Convert from a tuple to a package identifier. fromTuple :: (PackageName,Version) -> PackageIdentifier fromTuple (n,v) = PackageIdentifier n v -- | A parser for a package-version pair. packageIdentifierParser :: Parser PackageIdentifier packageIdentifierParser = do name <- packageNameParser char '-' PackageIdentifier name <$> versionParser -- | Convenient way to parse a package identifier from a 'Text'. parsePackageIdentifier :: MonadThrow m => Text -> m PackageIdentifier parsePackageIdentifier x = go x where go = either (const (throwM (PackageIdentifierParseFail x))) return . parseOnly (packageIdentifierParser <* endOfInput) -- | Convenience function for parsing from a 'String'. parsePackageIdentifierFromString :: MonadThrow m => String -> m PackageIdentifier parsePackageIdentifierFromString = parsePackageIdentifier . T.pack -- | Parse a 'PackageIdentifierRevision' parsePackageIdentifierRevision :: MonadThrow m => Text -> m PackageIdentifierRevision parsePackageIdentifierRevision x = go x where go = either (const (throwM (PackageIdentifierRevisionParseFail x))) return . parseOnly (parser <* endOfInput) parser = PackageIdentifierRevision <$> packageIdentifierParser <*> (cfiHash <|> cfiRevision <|> pure CFILatest) cfiHash = do _ <- string $ T.pack "@sha256:" hash' <- A.takeWhile (/= ',') hash'' <- either (\e -> fail $ "Invalid SHA256: " ++ show e) return $ mkCabalHashFromSHA256 hash' msize <- optional $ do _ <- A.char ',' A.decimal A.endOfInput return $ CFIHash msize hash'' cfiRevision = do _ <- string $ T.pack "@rev:" y <- A.decimal A.endOfInput return $ CFIRevision y -- | Get a string representation of the package identifier; name-ver. packageIdentifierString :: PackageIdentifier -> String packageIdentifierString (PackageIdentifier n v) = show n ++ "-" ++ show v -- | Get a string representation of the package identifier with revision; name-ver[@hashtype:hash[,size]]. packageIdentifierRevisionString :: PackageIdentifierRevision -> String packageIdentifierRevisionString (PackageIdentifierRevision ident cfi) = concat $ packageIdentifierString ident : rest where rest = case cfi of CFILatest -> [] CFIHash msize hash' -> "@sha256:" : T.unpack (cabalHashToText hash') : showSize msize CFIRevision rev -> ["@rev:", show rev] showSize Nothing = [] showSize (Just int) = [',' : show int] -- | Get a Text representation of the package identifier; name-ver. packageIdentifierText :: PackageIdentifier -> Text packageIdentifierText = T.pack . packageIdentifierString toCabalPackageIdentifier :: PackageIdentifier -> C.PackageIdentifier toCabalPackageIdentifier x = C.PackageIdentifier (toCabalPackageName (packageIdentifierName x)) (toCabalVersion (packageIdentifierVersion x)) fromCabalPackageIdentifier :: C.PackageIdentifier -> PackageIdentifier fromCabalPackageIdentifier (C.PackageIdentifier name version) = PackageIdentifier (fromCabalPackageName name) (fromCabalVersion version) stack-1.9.3.1/src/Stack/Types/PackageIndex.hs0000644000000000000000000001530313455617610017007 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude #-} {-# LANGUAGE DeriveGeneric #-} {-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE GeneralizedNewtypeDeriving #-} {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE DataKinds #-} {-# LANGUAGE DeriveDataTypeable #-} module Stack.Types.PackageIndex ( PackageDownload (..) , HSPackageDownload (..) , PackageCache (..) , OffsetSize (..) -- ** PackageIndex, IndexName & IndexLocation , PackageIndex(..) , IndexName(..) , indexNameText , IndexType (..) , HackageSecurity (..) ) where import Data.Aeson.Extended import qualified Data.Foldable as F import qualified Data.HashMap.Strict as HashMap import qualified Data.Map.Strict as Map import qualified Data.Text as T import Data.Text.Encoding (encodeUtf8, decodeUtf8) import Path import Stack.Prelude import Stack.Types.PackageName import Stack.Types.PackageIdentifier import Stack.Types.Version import Data.List.NonEmpty (NonEmpty) -- | Cached information about packages in an index. We have a mapping -- from package name to a version map. Within the version map, we map -- from the version to information on an individual version. Each -- version has optional download information (about the package's -- tarball itself), and cabal file information. The cabal file -- information is a non-empty list of all cabal file revisions. Each -- file revision indicates the hash of the contents of the cabal file, -- and the offset into the index tarball. -- -- The reason for each 'Version' mapping to a two element list of -- 'CabalHash'es is because some older Stackage snapshots have CRs in -- their cabal files. For compatibility with these older snapshots, -- both hashes are stored: the first element of the two element list -- being the original hash, and the (potential) second element with -- the CRs stripped. [Note: This is was initially stored as a two -- element list, and cannot be easily packed into more explict ADT or -- newtype because of some template-haskell that would need to be -- modified as well: the 'versionedDecodeOrLoad' function call found -- in the 'getPackageCaches' function in 'Stack.PackageIndex'.] -- -- It's assumed that cabal files appear in the index tarball in the -- correct revision order. newtype PackageCache index = PackageCache (HashMap PackageName (HashMap Version (index, Maybe PackageDownload, NonEmpty ([CabalHash], OffsetSize)))) deriving (Generic, Eq, Show, Data, Typeable, Store, NFData) instance Semigroup (PackageCache index) where PackageCache x <> PackageCache y = PackageCache (HashMap.unionWith HashMap.union x y) instance Monoid (PackageCache index) where mempty = PackageCache HashMap.empty mappend = (<>) -- | offset in bytes into the 01-index.tar file for the .cabal file -- contents, and size in bytes of the .cabal file data OffsetSize = OffsetSize !Int64 !Int64 deriving (Generic, Eq, Show, Data, Typeable) instance Store OffsetSize instance NFData OffsetSize data PackageDownload = PackageDownload { pdSHA256 :: !StaticSHA256 , pdUrl :: !ByteString , pdSize :: !Word64 } deriving (Show, Generic, Eq, Data, Typeable) instance Store PackageDownload instance NFData PackageDownload instance FromJSON PackageDownload where parseJSON = withObject "PackageDownload" $ \o -> do hashes <- o .: "package-hashes" sha256' <- maybe mzero return (Map.lookup ("SHA256" :: Text) hashes) sha256 <- case mkStaticSHA256FromText sha256' of Left e -> fail $ "Invalid sha256: " ++ show e Right x -> return x locs <- o .: "package-locations" url <- case reverse locs of [] -> mzero x:_ -> return x size <- o .: "package-size" return PackageDownload { pdSHA256 = sha256 , pdUrl = encodeUtf8 url , pdSize = size } -- | Hackage Security provides a different JSON format, we'll have our -- own JSON parser for it. newtype HSPackageDownload = HSPackageDownload { unHSPackageDownload :: PackageDownload } instance FromJSON HSPackageDownload where parseJSON = withObject "HSPackageDownload" $ \o1 -> do o2 <- o1 .: "signed" Object o3 <- o2 .: "targets" Object o4:_ <- return $ F.toList o3 len <- o4 .: "length" hashes <- o4 .: "hashes" sha256' <- hashes .: "sha256" sha256 <- case mkStaticSHA256FromText sha256' of Left e -> fail $ "Invalid sha256: " ++ show e Right x -> return x return $ HSPackageDownload PackageDownload { pdSHA256 = sha256 , pdSize = len , pdUrl = "" } -- | Unique name for a package index newtype IndexName = IndexName { unIndexName :: ByteString } deriving (Show, Eq, Ord, Hashable, Store) indexNameText :: IndexName -> Text indexNameText = decodeUtf8 . unIndexName instance ToJSON IndexName where toJSON = toJSON . indexNameText instance FromJSON IndexName where parseJSON = withText "IndexName" $ \t -> case parseRelDir (T.unpack t) of Left e -> fail $ "Invalid index name: " ++ show e Right _ -> return $ IndexName $ encodeUtf8 t data IndexType = ITHackageSecurity !HackageSecurity | ITVanilla deriving (Show, Eq, Ord) data HackageSecurity = HackageSecurity { hsKeyIds :: ![Text] , hsKeyThreshold :: !Int } deriving (Show, Eq, Ord) instance FromJSON HackageSecurity where parseJSON = withObject "HackageSecurity" $ \o -> HackageSecurity <$> o .: "keyids" <*> o .: "key-threshold" -- | Information on a single package index data PackageIndex = PackageIndex { indexName :: !IndexName , indexLocation :: !Text -- ^ URL for the tarball or, in the case of Hackage Security, the -- root of the directory , indexType :: !IndexType , indexDownloadPrefix :: !Text -- ^ URL prefix for downloading packages , indexRequireHashes :: !Bool -- ^ Require that hashes and package size information be available for packages in this index } deriving Show instance FromJSON (WithJSONWarnings PackageIndex) where parseJSON = withObjectWarnings "PackageIndex" $ \o -> do name <- o ..: "name" prefix <- o ..: "download-prefix" http <- o ..: "http" mhackageSecurity <- o ..:? "hackage-security" let indexType' = maybe ITVanilla ITHackageSecurity mhackageSecurity reqHashes <- o ..:? "require-hashes" ..!= False return PackageIndex { indexName = name , indexLocation = http , indexType = indexType' , indexDownloadPrefix = prefix , indexRequireHashes = reqHashes } stack-1.9.3.1/src/Stack/Types/PackageName.hs0000644000000000000000000001225113455617610016617 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude #-} {-# LANGUAGE BangPatterns #-} {-# LANGUAGE TemplateHaskell #-} {-# LANGUAGE DeriveGeneric #-} {-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE GeneralizedNewtypeDeriving #-} {-# LANGUAGE DeriveDataTypeable #-} {-# LANGUAGE TupleSections #-} -- | Names for packages. module Stack.Types.PackageName (PackageName ,PackageNameParseFail(..) ,packageNameParser ,parsePackageName ,parsePackageNameFromString ,packageNameString ,packageNameText ,fromCabalPackageName ,toCabalPackageName ,parsePackageNameFromFilePath ,mkPackageName ,packageNameArgument) where import Stack.Prelude import Data.Aeson.Extended import Data.Attoparsec.Combinators import Data.Attoparsec.Text import Data.List (intercalate) import qualified Data.Text as T import qualified Distribution.Package as Cabal import Language.Haskell.TH import Language.Haskell.TH.Syntax import qualified Options.Applicative as O import Path -- | A parse fail. data PackageNameParseFail = PackageNameParseFail Text | CabalFileNameParseFail FilePath | CabalFileNameInvalidPackageName FilePath deriving (Typeable) instance Exception PackageNameParseFail instance Show PackageNameParseFail where show (PackageNameParseFail bs) = "Invalid package name: " ++ show bs show (CabalFileNameParseFail fp) = "Invalid file path for cabal file, must have a .cabal extension: " ++ fp show (CabalFileNameInvalidPackageName fp) = "cabal file names must use valid package names followed by a .cabal extension, the following is invalid: " ++ fp -- | A package name. newtype PackageName = PackageName Text deriving (Eq,Ord,Typeable,Data,Generic,Hashable,NFData,Store,ToJSON,ToJSONKey) instance Lift PackageName where lift (PackageName n) = appE (conE 'PackageName) (stringE (T.unpack n)) instance Show PackageName where show (PackageName n) = T.unpack n instance Display PackageName where display (PackageName n) = display n instance FromJSON PackageName where parseJSON j = do s <- parseJSON j case parsePackageNameFromString s of Nothing -> fail ("Couldn't parse package name: " ++ s) Just ver -> return ver instance FromJSONKey PackageName where fromJSONKey = FromJSONKeyTextParser $ \k -> either (fail . show) return $ parsePackageName k -- | Attoparsec parser for a package name packageNameParser :: Parser PackageName packageNameParser = fmap (PackageName . T.pack . intercalate "-") (sepBy1 word (char '-')) where word = concat <$> sequence [many digit, pured letter, many (alternating letter digit)] -- | Make a package name. mkPackageName :: String -> Q Exp mkPackageName s = case parsePackageNameFromString s of Nothing -> qRunIO $ throwString ("Invalid package name: " ++ show s) Just pn -> [|pn|] -- | Parse a package name from a 'Text'. parsePackageName :: MonadThrow m => Text -> m PackageName parsePackageName x = go x where go = either (const (throwM (PackageNameParseFail x))) return . parseOnly (packageNameParser <* endOfInput) -- | Parse a package name from a 'String'. parsePackageNameFromString :: MonadThrow m => String -> m PackageName parsePackageNameFromString = parsePackageName . T.pack -- | Produce a string representation of a package name. packageNameString :: PackageName -> String packageNameString (PackageName n) = T.unpack n -- | Produce a string representation of a package name. packageNameText :: PackageName -> Text packageNameText (PackageName n) = n -- | Convert from a Cabal package name. fromCabalPackageName :: Cabal.PackageName -> PackageName fromCabalPackageName name = let !x = T.pack $ Cabal.unPackageName name in PackageName x -- | Convert to a Cabal package name. toCabalPackageName :: PackageName -> Cabal.PackageName toCabalPackageName (PackageName name) = let !x = T.unpack name in Cabal.mkPackageName x -- | Parse a package name from a file path. parsePackageNameFromFilePath :: MonadThrow m => Path a File -> m PackageName parsePackageNameFromFilePath fp = do base <- clean $ toFilePath $ filename fp case parsePackageNameFromString base of Nothing -> throwM $ CabalFileNameInvalidPackageName $ toFilePath fp Just x -> return x where clean = liftM reverse . strip . reverse strip ('l':'a':'b':'a':'c':'.':xs) = return xs strip _ = throwM (CabalFileNameParseFail (toFilePath fp)) -- | An argument which accepts a template name of the format -- @foo.hsfiles@. packageNameArgument :: O.Mod O.ArgumentFields PackageName -> O.Parser PackageName packageNameArgument = O.argument (do s <- O.str either O.readerError return (p s)) where p s = case parsePackageNameFromString s of Just x -> Right x Nothing -> Left $ unlines [ "Expected valid package name, but got: " ++ s , "Package names consist of one or more alphanumeric words separated by hyphens." , "To avoid ambiguity with version numbers, each of these words must contain at least one letter." ] stack-1.9.3.1/src/Stack/Types/Resolver.hs0000644000000000000000000002263513455617610016273 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude #-} {-# LANGUAGE ConstraintKinds #-} {-# LANGUAGE CPP #-} {-# LANGUAGE DeriveDataTypeable #-} {-# LANGUAGE DeriveFoldable #-} {-# LANGUAGE DeriveFunctor #-} {-# LANGUAGE DeriveGeneric #-} {-# LANGUAGE DeriveTraversable #-} {-# LANGUAGE FlexibleContexts #-} {-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE MultiWayIf #-} {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TypeFamilies #-} {-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE DataKinds #-} {-# LANGUAGE GADTs #-} {-# LANGUAGE UndecidableInstances #-} module Stack.Types.Resolver (Resolver ,IsLoaded(..) ,LoadedResolver ,ResolverWith(..) ,parseResolverText ,AbstractResolver(..) ,readAbstractResolver ,resolverRawName ,SnapName(..) ,Snapshots (..) ,renderSnapName ,parseSnapName ,SnapshotHash ,trimmedSnapshotHash ,snapshotHashToBS ,snapshotHashFromBS ,snapshotHashFromDigest ,parseCustomLocation ) where import Crypto.Hash as Hash (hash, Digest, SHA256) import Data.Aeson.Extended (ToJSON, toJSON, FromJSON, parseJSON, withObject, (.:), withText) import qualified Data.ByteString as B import qualified Data.ByteString.Base64.URL as B64URL import qualified Data.HashMap.Strict as HashMap import qualified Data.IntMap.Strict as IntMap import qualified Data.Text as T import Data.Text.Encoding (decodeUtf8) import Data.Text.Read (decimal) import Data.Time (Day) import Network.HTTP.StackClient (Request, parseUrlThrow) import Options.Applicative (ReadM) import qualified Options.Applicative.Types as OA import Path import Stack.Prelude import Stack.Types.Compiler import Stack.Types.PackageIdentifier import qualified System.FilePath as FP data IsLoaded = Loaded | NotLoaded type LoadedResolver = ResolverWith SnapshotHash type Resolver = ResolverWith (Either Request FilePath) -- TODO: once GHC 8.0 is the lowest version we support, make these into -- actual haddock comments... -- | How we resolve which dependencies to install given a set of packages. data ResolverWith customContents = ResolverStackage !SnapName -- ^ Use an official snapshot from the Stackage project, either an -- LTS Haskell or Stackage Nightly. | ResolverCompiler !(CompilerVersion 'CVWanted) -- ^ Require a specific compiler version, but otherwise provide no -- build plan. Intended for use cases where end user wishes to -- specify all upstream dependencies manually, such as using a -- dependency solver. | ResolverCustom !Text !customContents -- ^ A custom resolver based on the given location (as a raw URL -- or filepath). If @customContents@ is a @Either Request -- FilePath@, it represents the parsed location value (with -- filepaths resolved relative to the directory containing the -- file referring to the custom snapshot). Once it has been loaded -- from disk, it will be replaced with a @SnapshotHash@ value, -- which is used to store cached files. deriving (Generic, Typeable, Show, Data, Eq, Functor, Foldable, Traversable) instance Store LoadedResolver instance NFData LoadedResolver instance ToJSON (ResolverWith a) where toJSON x = case x of ResolverStackage name -> toJSON $ renderSnapName name ResolverCompiler version -> toJSON $ compilerVersionText version ResolverCustom loc _ -> toJSON loc instance a ~ () => FromJSON (ResolverWith a) where parseJSON = withText "ResolverWith ()" $ return . parseResolverText -- | Convert a Resolver into its @Text@ representation for human -- presentation. When possible, you should prefer @sdResolverName@, as -- it will handle the human-friendly name inside a custom snapshot. resolverRawName :: ResolverWith a -> Text resolverRawName (ResolverStackage name) = renderSnapName name resolverRawName (ResolverCompiler v) = compilerVersionText v resolverRawName (ResolverCustom loc _ ) = "custom: " <> loc parseCustomLocation :: MonadThrow m => Maybe (Path Abs Dir) -- ^ directory config value was read from -> ResolverWith () -- could technically be any type parameter, restricting to help with type safety -> m Resolver parseCustomLocation mdir (ResolverCustom t ()) = ResolverCustom t <$> case parseUrlThrow $ T.unpack t of Nothing -> Right <$> do dir <- case mdir of Nothing -> throwM $ FilepathInDownloadedSnapshot t Just x -> return x let rel = T.unpack $ fromMaybe t $ T.stripPrefix "file://" t <|> T.stripPrefix "file:" t return $ toFilePath dir FP. rel Just req -> return $ Left req parseCustomLocation _ (ResolverStackage name) = return $ ResolverStackage name parseCustomLocation _ (ResolverCompiler cv) = return $ ResolverCompiler cv -- | Parse a @Resolver@ from a @Text@ parseResolverText :: Text -> ResolverWith () parseResolverText t | Right x <- parseSnapName t = ResolverStackage x | Just v <- parseCompilerVersion t = ResolverCompiler v | otherwise = ResolverCustom t () -- | Either an actual resolver value, or an abstract description of one (e.g., -- latest nightly). data AbstractResolver = ARLatestNightly | ARLatestLTS | ARLatestLTSMajor !Int | ARResolver !(ResolverWith ()) | ARGlobal deriving Show readAbstractResolver :: ReadM AbstractResolver readAbstractResolver = do s <- OA.readerAsk case s of "global" -> return ARGlobal "nightly" -> return ARLatestNightly "lts" -> return ARLatestLTS 'l':'t':'s':'-':x | Right (x', "") <- decimal $ T.pack x -> return $ ARLatestLTSMajor x' _ -> return $ ARResolver $ parseResolverText $ T.pack s -- | The name of an LTS Haskell or Stackage Nightly snapshot. data SnapName = LTS !Int !Int | Nightly !Day deriving (Generic, Typeable, Show, Data, Eq) instance Store SnapName instance NFData SnapName instance Display SnapName where display = display . renderSnapName data BuildPlanTypesException = ParseSnapNameException !Text | ParseResolverException !Text | FilepathInDownloadedSnapshot !Text deriving Typeable instance Exception BuildPlanTypesException instance Show BuildPlanTypesException where show (ParseSnapNameException t) = "Invalid snapshot name: " ++ T.unpack t show (ParseResolverException t) = concat [ "Invalid resolver value: " , T.unpack t , ". Possible valid values include lts-2.12, nightly-YYYY-MM-DD, ghc-7.10.2, and ghcjs-0.1.0_ghc-7.10.2. " , "See https://www.stackage.org/snapshots for a complete list." ] show (FilepathInDownloadedSnapshot url) = unlines [ "Downloaded snapshot specified a 'resolver: { location: filepath }' " , "field, but filepaths are not allowed in downloaded snapshots.\n" , "Filepath specified: " ++ T.unpack url ] -- | Convert a 'SnapName' into its short representation, e.g. @lts-2.8@, -- @nightly-2015-03-05@. renderSnapName :: SnapName -> Text renderSnapName (LTS x y) = T.pack $ concat ["lts-", show x, ".", show y] renderSnapName (Nightly d) = T.pack $ "nightly-" ++ show d -- | Parse the short representation of a 'SnapName'. parseSnapName :: MonadThrow m => Text -> m SnapName parseSnapName t0 = case lts <|> nightly of Nothing -> throwM $ ParseSnapNameException t0 Just sn -> return sn where lts = do t1 <- T.stripPrefix "lts-" t0 Right (x, t2) <- Just $ decimal t1 t3 <- T.stripPrefix "." t2 Right (y, "") <- Just $ decimal t3 return $ LTS x y nightly = do t1 <- T.stripPrefix "nightly-" t0 Nightly <$> readMaybe (T.unpack t1) -- | Most recent Nightly and newest LTS version per major release. data Snapshots = Snapshots { snapshotsNightly :: !Day , snapshotsLts :: !(IntMap Int) } deriving Show instance FromJSON Snapshots where parseJSON = withObject "Snapshots" $ \o -> Snapshots <$> (o .: "nightly" >>= parseNightly) <*> fmap IntMap.unions (mapM (parseLTS . snd) $ filter (isLTS . fst) $ HashMap.toList o) where parseNightly t = case parseSnapName t of Left e -> fail $ show e Right (LTS _ _) -> fail "Unexpected LTS value" Right (Nightly d) -> return d isLTS = ("lts-" `T.isPrefixOf`) parseLTS = withText "LTS" $ \t -> case parseSnapName t of Left e -> fail $ show e Right (LTS x y) -> return $ IntMap.singleton x y Right (Nightly _) -> fail "Unexpected nightly value" newtype SnapshotHash = SnapshotHash { unSnapshotHash :: StaticSHA256 } deriving (Generic, Typeable, Show, Data, Eq) instance Store SnapshotHash instance NFData SnapshotHash -- | Return the first 12 characters of the hash as a B64URL-encoded -- string. trimmedSnapshotHash :: SnapshotHash -> Text trimmedSnapshotHash = decodeUtf8 . B.take 12 . B64URL.encode . staticSHA256ToRaw . unSnapshotHash -- | Return the raw bytes in the hash snapshotHashToBS :: SnapshotHash -> ByteString snapshotHashToBS = staticSHA256ToRaw . unSnapshotHash -- | Create a new SnapshotHash by SHA256 hashing the given contents snapshotHashFromBS :: ByteString -> SnapshotHash snapshotHashFromBS = snapshotHashFromDigest . Hash.hash -- | Create a new SnapshotHash from the given digest snapshotHashFromDigest :: Digest SHA256 -> SnapshotHash snapshotHashFromDigest = SnapshotHash . mkStaticSHA256FromDigest stack-1.9.3.1/src/Stack/Types/Runner.hs0000644000000000000000000001030413455617610015731 0ustar0000000000000000{-# LANGUAGE CPP #-} {-# LANGUAGE ConstraintKinds #-} {-# LANGUAGE DeriveGeneric #-} {-# LANGUAGE FlexibleContexts #-} {-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE MultiParamTypeClasses #-} {-# LANGUAGE NoImplicitPrelude #-} {-# LANGUAGE TypeFamilies #-} {-# LANGUAGE UndecidableInstances #-} -- | Run environment module Stack.Types.Runner ( Runner (..) , HasRunner (..) , terminalL , useColorL , reExecL , ColorWhen (..) , withRunner ) where import Distribution.PackageDescription (GenericPackageDescription) import Lens.Micro import Stack.Prelude hiding (lift) import Stack.Constants import Stack.Types.PackageIdentifier (PackageIdentifierRevision) import System.Console.ANSI import RIO.Process (HasProcessContext (..), ProcessContext, mkDefaultProcessContext) import System.Terminal -- | Monadic environment. data Runner = Runner { runnerReExec :: !Bool , runnerTerminal :: !Bool , runnerUseColor :: !Bool , runnerLogFunc :: !LogFunc , runnerTermWidth :: !Int , runnerProcessContext :: !ProcessContext , runnerParsedCabalFiles :: !(IORef ( Map PackageIdentifierRevision GenericPackageDescription , Map (Path Abs Dir) (GenericPackageDescription, Path Abs File) )) -- ^ Cache of previously parsed cabal files. -- -- TODO: This is really an ugly hack to avoid spamming the user with -- warnings when we parse cabal files multiple times and bypass -- performance issues. Ideally: we would just design the system such -- that it only ever parses a cabal file once. But for now, this is -- a decent workaround. See: -- . } class (HasProcessContext env, HasLogFunc env) => HasRunner env where runnerL :: Lens' env Runner instance HasProcessContext Runner where processContextL = lens runnerProcessContext (\x y -> x { runnerProcessContext = y }) instance HasRunner Runner where runnerL = id terminalL :: HasRunner env => Lens' env Bool terminalL = runnerL.lens runnerTerminal (\x y -> x { runnerTerminal = y }) useColorL :: HasRunner env => Lens' env Bool useColorL = runnerL.lens runnerUseColor (\x y -> x { runnerUseColor = y }) reExecL :: HasRunner env => Lens' env Bool reExecL = runnerL.lens runnerReExec (\x y -> x { runnerReExec = y }) -------------------------------------------------------------------------------- -- Logging functionality instance HasLogFunc Runner where logFuncL = lens runnerLogFunc (\x y -> x { runnerLogFunc = y }) -- | With a 'Runner', do the thing withRunner :: MonadUnliftIO m => LogLevel -> Bool -- ^ use time? -> Bool -- ^ terminal? -> ColorWhen -> Maybe Int -- ^ terminal width override -> Bool -- ^ reexec? -> (Runner -> m a) -> m a withRunner logLevel useTime terminal colorWhen widthOverride reExec inner = do useColor <- case colorWhen of ColorNever -> return False ColorAlways -> return True ColorAuto -> liftIO $ hSupportsANSI stderr termWidth <- clipWidth <$> maybe (fromMaybe defaultTerminalWidth <$> liftIO getTerminalWidth) pure widthOverride ref <- newIORef mempty menv <- mkDefaultProcessContext logOptions0 <- logOptionsHandle stderr False let logOptions = setLogUseColor useColor $ setLogUseTime useTime $ setLogMinLevel logLevel $ setLogVerboseFormat (logLevel <= LevelDebug) $ setLogTerminal terminal logOptions0 withLogFunc logOptions $ \logFunc -> inner Runner { runnerReExec = reExec , runnerTerminal = terminal , runnerUseColor = useColor , runnerLogFunc = logFunc , runnerTermWidth = termWidth , runnerParsedCabalFiles = ref , runnerProcessContext = menv } where clipWidth w | w < minTerminalWidth = minTerminalWidth | w > maxTerminalWidth = maxTerminalWidth | otherwise = w data ColorWhen = ColorNever | ColorAlways | ColorAuto deriving (Eq, Show, Generic) stack-1.9.3.1/src/Stack/Types/Sig.hs0000644000000000000000000000535613455666157015227 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude #-} {-# LANGUAGE DeriveDataTypeable #-} {-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE OverloadedStrings #-} {-| Module : Stack.Types.Sig Description : Signature Types Copyright : (c) 2015-2018, Stack contributors License : BSD3 Maintainer : Tim Dysinger Stability : experimental Portability : POSIX -} module Stack.Types.Sig (Signature(..), Fingerprint, mkFingerprint, SigException(..)) where import Stack.Prelude import Data.Aeson (Value(..), ToJSON(..), FromJSON(..)) import qualified Data.ByteString as SB import Data.Char (isHexDigit) import qualified Data.Text as T import Stack.Types.PackageName -- | A GPG signature. newtype Signature = Signature ByteString deriving (Ord,Eq) instance Show Signature where show (Signature s) = "Signature " ++ (if SB.length s > 140 then show (SB.take 140 s) ++ "..." else show (SB.take 140 s)) -- | The GPG fingerprint. newtype Fingerprint = Fingerprint Text deriving (Eq,Ord) mkFingerprint :: Text -> Fingerprint mkFingerprint = Fingerprint . hexText hexText :: Text -> Text hexText = T.toUpper . T.dropWhile (not . isHexDigit) instance Show Fingerprint where show (Fingerprint hex) = T.unpack (hexText hex) instance FromJSON Fingerprint where parseJSON j = Fingerprint . hexText <$> parseJSON j instance ToJSON Fingerprint where toJSON (Fingerprint hex) = String (hexText hex) instance IsString Fingerprint where fromString = Fingerprint . hexText . T.pack instance FromJSON (Aeson PackageName) where parseJSON j = do s <- parseJSON j case parsePackageName s of Just name -> return (Aeson name) Nothing -> fail ("Invalid package name: " <> T.unpack s) -- | Handy wrapper for orphan instances. newtype Aeson a = Aeson { _unAeson :: a } deriving (Ord,Eq) -- | Exceptions data SigException = GPGFingerprintException String | GPGNotFoundException | GPGSignException String | GPGVerifyException String | SigInvalidSDistTarBall | SigNoProjectRootException | SigServiceException String deriving (Typeable) instance Exception SigException instance Show SigException where show (GPGFingerprintException e) = "Error extracting a GPG fingerprint " <> e show GPGNotFoundException = "Unable to find gpg2 or gpg executable" show (GPGSignException e) = "Error signing with GPG " <> e show (GPGVerifyException e) = "Error verifying with GPG " <> e show SigNoProjectRootException = "Missing Project Root" show SigInvalidSDistTarBall = "Invalid sdist tarball" show (SigServiceException e) = "Error with the Signature Service " <> e stack-1.9.3.1/src/Stack/Types/TemplateName.hs0000644000000000000000000001346113455617610017043 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude #-} {-# LANGUAGE ViewPatterns #-} {-# LANGUAGE TemplateHaskell #-} {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE GeneralizedNewtypeDeriving #-} -- | Template name handling. module Stack.Types.TemplateName ( TemplateName , RepoTemplatePath (..) , RepoService (..) , TemplatePath (..) , mkTemplateName , templateName , templatePath , parseTemplateNameFromString , parseRepoPathWithService , templateNameArgument , templateParamArgument ) where import Data.Aeson (FromJSON (..), withText) import qualified Data.Text as T import Language.Haskell.TH import Network.HTTP.StackClient (parseRequest) import qualified Options.Applicative as O import Path import Path.Internal import Stack.Prelude -- | A template name. data TemplateName = TemplateName !Text !TemplatePath deriving (Ord,Eq,Show) data TemplatePath = AbsPath (Path Abs File) -- ^ an absolute path on the filesystem | RelPath (Path Rel File) -- ^ a relative path on the filesystem, or relative to -- the template repository | UrlPath String -- ^ a full URL | RepoPath RepoTemplatePath deriving (Eq, Ord, Show) -- | Details for how to access a template from a remote repo. data RepoTemplatePath = RepoTemplatePath { rtpService :: RepoService , rtpUser :: Text , rtpTemplate :: Text } deriving (Eq, Ord, Show) -- | Services from which templates can be retrieved from a repository. data RepoService = Github | Gitlab | Bitbucket deriving (Eq, Ord, Show) instance FromJSON TemplateName where parseJSON = withText "TemplateName" $ either fail return . parseTemplateNameFromString . T.unpack -- | An argument which accepts a template name of the format -- @foo.hsfiles@ or @foo@, ultimately normalized to @foo@. templateNameArgument :: O.Mod O.ArgumentFields TemplateName -> O.Parser TemplateName templateNameArgument = O.argument (do string <- O.str either O.readerError return (parseTemplateNameFromString string)) -- | An argument which accepts a @key:value@ pair for specifying parameters. templateParamArgument :: O.Mod O.OptionFields (Text,Text) -> O.Parser (Text,Text) templateParamArgument = O.option (do string <- O.str either O.readerError return (parsePair string)) where parsePair :: String -> Either String (Text, Text) parsePair s = case break (==':') s of (key,':':value@(_:_)) -> Right (T.pack key, T.pack value) _ -> Left ("Expected key:value format for argument: " <> s) -- | Parse a template name from a string. parseTemplateNameFromString :: String -> Either String TemplateName parseTemplateNameFromString fname = case T.stripSuffix ".hsfiles" (T.pack fname) of Nothing -> parseValidFile (T.pack fname) (fname <> ".hsfiles") fname Just prefix -> parseValidFile prefix fname fname where parseValidFile prefix hsf orig = maybe (Left expected) Right $ asum (validParses prefix hsf orig) validParses prefix hsf orig = -- NOTE: order is important [ TemplateName prefix . RepoPath <$> parseRepoPath hsf , TemplateName (T.pack orig) . UrlPath <$> (parseRequest orig *> Just orig) , TemplateName prefix . AbsPath <$> parseAbsFile hsf , TemplateName prefix . RelPath <$> parseRelFile hsf ] expected = "Expected a template like: foo or foo.hsfiles or\ \ https://example.com/foo.hsfiles or github:user/foo" -- | Make a template name. mkTemplateName :: String -> Q Exp mkTemplateName s = case parseTemplateNameFromString s of Left{} -> runIO $ throwString ("Invalid template name: " ++ show s) Right (TemplateName (T.unpack -> prefix) p) -> [|TemplateName (T.pack prefix) $(pn)|] where pn = case p of AbsPath (Path fp) -> [|AbsPath (Path fp)|] RelPath (Path fp) -> [|RelPath (Path fp)|] UrlPath fp -> [|UrlPath fp|] RepoPath (RepoTemplatePath sv u t) -> case sv of Github -> [|RepoPath $ RepoTemplatePath Github u t|] Gitlab -> [|RepoPath $ RepoTemplatePath Gitlab u t|] Bitbucket -> [|RepoPath $ RepoTemplatePath Bitbucket u t|] -- | Get a text representation of the template name. templateName :: TemplateName -> Text templateName (TemplateName prefix _) = prefix -- | Get the path of the template. templatePath :: TemplateName -> TemplatePath templatePath (TemplateName _ fp) = fp defaultRepoUserForService :: RepoService -> Maybe Text defaultRepoUserForService Github = Just "commercialhaskell" defaultRepoUserForService _ = Nothing -- | Parses a template path of the form @github:user/template@. parseRepoPath :: String -> Maybe RepoTemplatePath parseRepoPath s = case T.splitOn ":" (T.pack s) of ["github" , rest] -> parseRepoPathWithService Github rest ["gitlab" , rest] -> parseRepoPathWithService Gitlab rest ["bitbucket" , rest] -> parseRepoPathWithService Bitbucket rest _ -> Nothing -- | Parses a template path of the form @user/template@, given a service parseRepoPathWithService :: RepoService -> Text -> Maybe RepoTemplatePath parseRepoPathWithService service path = case T.splitOn "/" path of [user, name] -> Just $ RepoTemplatePath service user name [name] -> do repoUser <- defaultRepoUserForService service Just $ RepoTemplatePath service repoUser name _ -> Nothing stack-1.9.3.1/src/Stack/Types/Version.hs0000644000000000000000000001727213455617610016120 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude #-} {-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE TemplateHaskell #-} {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE BangPatterns #-} {-# LANGUAGE DeriveGeneric #-} {-# LANGUAGE GeneralizedNewtypeDeriving #-} {-# LANGUAGE DeriveDataTypeable #-} -- | Versions for packages. module Stack.Types.Version (Version ,Cabal.VersionRange -- TODO in the future should have a newtype wrapper ,IntersectingVersionRange(..) ,VersionCheck(..) ,versionParser ,parseVersion ,parseVersionFromString ,versionString ,versionText ,toCabalVersion ,fromCabalVersion ,mkVersion ,versionRangeText ,withinRange ,Stack.Types.Version.intersectVersionRanges ,toMajorVersion ,latestApplicableVersion ,checkVersion ,nextMajorVersion ,UpgradeTo(..) ,minorVersion ,stackVersion ,stackMinorVersion) where import Stack.Prelude hiding (Vector) import Data.Aeson.Extended import Data.Attoparsec.Text import Data.Hashable (Hashable (..)) import Data.List import qualified Data.Set as Set import qualified Data.Text as T import Data.Vector.Unboxed (Vector) import qualified Data.Vector.Unboxed as V import Distribution.Text (disp) import qualified Distribution.Version as Cabal import Language.Haskell.TH import Language.Haskell.TH.Syntax import qualified Paths_stack as Meta import Text.PrettyPrint (render) -- | A parse fail. newtype VersionParseFail = VersionParseFail Text deriving (Typeable) instance Exception VersionParseFail instance Show VersionParseFail where show (VersionParseFail bs) = "Invalid version: " ++ show bs -- | A Package upgrade; Latest or a specific version. data UpgradeTo = Specific Version | Latest deriving (Show) -- | A package version. newtype Version = Version {unVersion :: Vector Word} deriving (Eq,Ord,Typeable,Data,Generic,Store,NFData) instance Hashable Version where hashWithSalt i = hashWithSalt i . V.toList . unVersion instance Lift Version where lift (Version n) = appE (conE 'Version) (appE (varE 'V.fromList) (listE (map (litE . IntegerL . fromIntegral) (V.toList n)))) instance Show Version where show (Version v) = intercalate "." (map show (V.toList v)) instance Display Version where display = display . versionText instance ToJSON Version where toJSON = toJSON . versionText instance FromJSON Version where parseJSON j = do s <- parseJSON j case parseVersionFromString s of Nothing -> fail ("Couldn't parse package version: " ++ s) Just ver -> return ver instance FromJSONKey Version where fromJSONKey = FromJSONKeyTextParser $ \k -> either (fail . show) return $ parseVersion k newtype IntersectingVersionRange = IntersectingVersionRange { getIntersectingVersionRange :: Cabal.VersionRange } deriving Show instance Semigroup IntersectingVersionRange where IntersectingVersionRange l <> IntersectingVersionRange r = IntersectingVersionRange (l `Cabal.intersectVersionRanges` r) instance Monoid IntersectingVersionRange where mempty = IntersectingVersionRange Cabal.anyVersion mappend = (<>) -- | Attoparsec parser for a package version. versionParser :: Parser Version versionParser = do ls <- (:) <$> num <*> many num' let !v = V.fromList ls return (Version v) where num = decimal num' = point *> num point = satisfy (== '.') -- | Convenient way to parse a package version from a 'Text'. parseVersion :: MonadThrow m => Text -> m Version parseVersion x = go x where go = either (const (throwM (VersionParseFail x))) return . parseOnly (versionParser <* endOfInput) -- | Migration function. parseVersionFromString :: MonadThrow m => String -> m Version parseVersionFromString = parseVersion . T.pack -- | Get a string representation of a package version. versionString :: Version -> String versionString (Version v) = intercalate "." (map show (V.toList v)) -- | Get a string representation of a package version. versionText :: Version -> Text versionText (Version v) = T.intercalate "." (map (T.pack . show) (V.toList v)) -- | Convert to a Cabal version. toCabalVersion :: Version -> Cabal.Version toCabalVersion (Version v) = Cabal.mkVersion (map fromIntegral (V.toList v)) -- | Convert from a Cabal version. fromCabalVersion :: Cabal.Version -> Version fromCabalVersion vs = let !v = V.fromList (map fromIntegral (Cabal.versionNumbers vs)) in Version v -- | Make a package version. mkVersion :: String -> Q Exp mkVersion s = case parseVersionFromString s of Nothing -> qRunIO $ throwString ("Invalid package version: " ++ show s) Just pn -> [|pn|] -- | Display a version range versionRangeText :: Cabal.VersionRange -> Text versionRangeText = T.pack . render . disp -- | Check if a version is within a version range. withinRange :: Version -> Cabal.VersionRange -> Bool withinRange v r = toCabalVersion v `Cabal.withinRange` r -- | A modified intersection which also simplifies, for better display. intersectVersionRanges :: Cabal.VersionRange -> Cabal.VersionRange -> Cabal.VersionRange intersectVersionRanges x y = Cabal.simplifyVersionRange $ Cabal.intersectVersionRanges x y -- | Returns the first two components, defaulting to 0 if not present toMajorVersion :: Version -> Version toMajorVersion (Version v) = case V.length v of 0 -> Version (V.fromList [0, 0]) 1 -> Version (V.fromList [V.head v, 0]) _ -> Version (V.fromList [V.head v, v V.! 1]) -- | Given a version range and a set of versions, find the latest version from -- the set that is within the range. latestApplicableVersion :: Cabal.VersionRange -> Set Version -> Maybe Version latestApplicableVersion r = listToMaybe . filter (`withinRange` r) . Set.toDescList -- | Get the next major version number for the given version nextMajorVersion :: Version -> Version nextMajorVersion (Version v) = case V.length v of 0 -> Version (V.fromList [0, 1]) 1 -> Version (V.fromList [V.head v, 1]) _ -> Version (V.fromList [V.head v, (v V.! 1) + 1]) data VersionCheck = MatchMinor | MatchExact | NewerMinor deriving (Show, Eq, Ord) instance ToJSON VersionCheck where toJSON MatchMinor = String "match-minor" toJSON MatchExact = String "match-exact" toJSON NewerMinor = String "newer-minor" instance FromJSON VersionCheck where parseJSON = withText expected $ \t -> case t of "match-minor" -> return MatchMinor "match-exact" -> return MatchExact "newer-minor" -> return NewerMinor _ -> fail ("Expected " ++ expected ++ ", but got " ++ show t) where expected = "VersionCheck value (match-minor, match-exact, or newer-minor)" checkVersion :: VersionCheck -> Version -> Version -> Bool checkVersion check (Version wanted) (Version actual) = case check of MatchMinor -> V.and (V.take 3 matching) MatchExact -> V.length wanted == V.length actual && V.and matching NewerMinor -> V.and (V.take 2 matching) && newerMinor where matching = V.zipWith (==) wanted actual newerMinor = case (wanted V.!? 2, actual V.!? 2) of (Nothing, _) -> True (Just _, Nothing) -> False (Just w, Just a) -> a >= w -- | Get minor version (excludes any patchlevel) minorVersion :: Version -> Version minorVersion (Version v) = Version (V.take 3 v) -- | Current Stack version stackVersion :: Version stackVersion = fromCabalVersion (Cabal.mkVersion' Meta.version) -- | Current Stack minor version (excludes patchlevel) stackMinorVersion :: Version stackMinorVersion = minorVersion stackVersion stack-1.9.3.1/src/Stack/Types/VersionIntervals.hs0000644000000000000000000000530313455617610020000 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude #-} {-# LANGUAGE DeriveGeneric #-} {-# LANGUAGE DeriveDataTypeable #-} module Stack.Types.VersionIntervals ( VersionIntervals , toVersionRange , fromVersionRange , withinIntervals , unionVersionIntervals , intersectVersionIntervals ) where import Stack.Types.Version import qualified Distribution.Version as C import Stack.Prelude newtype VersionIntervals = VersionIntervals [VersionInterval] deriving (Generic, Show, Eq, Data, Typeable) instance Store VersionIntervals instance NFData VersionIntervals data VersionInterval = VersionInterval { viLowerVersion :: !Version , viLowerBound :: !Bound , viUpper :: !(Maybe (Version, Bound)) } deriving (Generic, Show, Eq, Data, Typeable) instance Store VersionInterval instance NFData VersionInterval data Bound = ExclusiveBound | InclusiveBound deriving (Generic, Show, Eq, Data, Typeable) instance Store Bound instance NFData Bound toVersionRange :: VersionIntervals -> C.VersionRange toVersionRange = C.fromVersionIntervals . toCabal fromVersionRange :: C.VersionRange -> VersionIntervals fromVersionRange = fromCabal . C.toVersionIntervals withinIntervals :: Version -> VersionIntervals -> Bool withinIntervals v vi = C.withinIntervals (toCabalVersion v) (toCabal vi) unionVersionIntervals :: VersionIntervals -> VersionIntervals -> VersionIntervals unionVersionIntervals x y = fromCabal $ C.unionVersionIntervals (toCabal x) (toCabal y) intersectVersionIntervals :: VersionIntervals -> VersionIntervals -> VersionIntervals intersectVersionIntervals x y = fromCabal $ C.intersectVersionIntervals (toCabal x) (toCabal y) toCabal :: VersionIntervals -> C.VersionIntervals toCabal (VersionIntervals vi) = C.mkVersionIntervals $ map go vi where go (VersionInterval lowerV lowerB mupper) = ( C.LowerBound (toCabalVersion lowerV) (toCabalBound lowerB) , case mupper of Nothing -> C.NoUpperBound Just (v, b) -> C.UpperBound (toCabalVersion v) (toCabalBound b) ) fromCabal :: C.VersionIntervals -> VersionIntervals fromCabal = VersionIntervals . map go . C.versionIntervals where go (C.LowerBound lowerV lowerB, upper) = VersionInterval { viLowerVersion = fromCabalVersion lowerV , viLowerBound = fromCabalBound lowerB , viUpper = case upper of C.NoUpperBound -> Nothing C.UpperBound v b -> Just (fromCabalVersion v, fromCabalBound b) } toCabalBound :: Bound -> C.Bound toCabalBound ExclusiveBound = C.ExclusiveBound toCabalBound InclusiveBound = C.InclusiveBound fromCabalBound :: C.Bound -> Bound fromCabalBound C.ExclusiveBound = ExclusiveBound fromCabalBound C.InclusiveBound = InclusiveBound stack-1.9.3.1/src/Stack/Upgrade.hs0000644000000000000000000002534113455617610014752 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude #-} {-# LANGUAGE CPP #-} {-# LANGUAGE ConstraintKinds #-} {-# LANGUAGE FlexibleContexts #-} {-# LANGUAGE MultiParamTypeClasses #-} {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE RecordWildCards #-} {-# LANGUAGE TemplateHaskell #-} module Stack.Upgrade ( upgrade , UpgradeOpts , upgradeOpts ) where import Stack.Prelude hiding (force, Display (..)) import qualified Data.HashMap.Strict as HashMap import qualified Data.List import qualified Data.Map as Map import qualified Data.Text as T import Distribution.Version (mkVersion') import Lens.Micro (set) import Options.Applicative import Path import qualified Paths_stack as Paths import Stack.Build import Stack.Config -- Following import is redundant on non-Windows operating systems #ifdef WINDOWS import Stack.DefaultColorWhen (defaultColorWhen) #endif import Stack.Fetch import Stack.PackageIndex import Stack.PrettyPrint import Stack.Setup import Stack.Types.PackageIdentifier import Stack.Types.PackageIndex import Stack.Types.PackageName import Stack.Types.Version import Stack.Types.Config import Stack.Types.Resolver import System.Exit (ExitCode (ExitSuccess)) import System.Process (rawSystem, readProcess) import RIO.Process upgradeOpts :: Parser UpgradeOpts upgradeOpts = UpgradeOpts <$> (sourceOnly <|> optional binaryOpts) <*> (binaryOnly <|> optional sourceOpts) where binaryOnly = flag' Nothing (long "binary-only" <> help "Do not use a source upgrade path") sourceOnly = flag' Nothing (long "source-only" <> help "Do not use a binary upgrade path") binaryOpts = BinaryOpts <$> optional (strOption ( long "binary-platform" <> help "Platform type for archive to download" <> showDefault)) <*> switch (long "force-download" <> help "Download the latest available stack executable") <*> optional (strOption (long "binary-version" <> help "Download a specific stack version")) <*> optional (strOption (long "github-org" <> help "Github organization name")) <*> optional (strOption (long "github-repo" <> help "Github repository name")) sourceOpts = SourceOpts <$> ((\fromGit repo branch -> if fromGit then Just (repo, branch) else Nothing) <$> switch ( long "git" <> help "Clone from Git instead of downloading from Hackage (more dangerous)" ) <*> strOption ( long "git-repo" <> help "Clone from specified git repository" <> value "https://github.com/commercialhaskell/stack" <> showDefault ) <*> strOption ( long "git-branch" <> help "Clone from this git branch" <> value "master" <> showDefault )) data BinaryOpts = BinaryOpts { _boPlatform :: !(Maybe String) , _boForce :: !Bool -- ^ force a download, even if the downloaded version is older -- than what we are , _boVersion :: !(Maybe String) -- ^ specific version to download , _boGithubOrg :: !(Maybe String) , _boGithubRepo :: !(Maybe String) } deriving Show newtype SourceOpts = SourceOpts (Maybe (String, String)) -- repo and branch deriving Show data UpgradeOpts = UpgradeOpts { _uoBinary :: !(Maybe BinaryOpts) , _uoSource :: !(Maybe SourceOpts) } deriving Show upgrade :: HasConfig env => ConfigMonoid -> Maybe AbstractResolver -> Maybe String -- ^ git hash at time of building, if known -> UpgradeOpts -> RIO env () upgrade gConfigMonoid mresolver builtHash (UpgradeOpts mbo mso) = case (mbo, mso) of -- FIXME It would be far nicer to capture this case in the -- options parser itself so we get better error messages, but -- I can't think of a way to make it happen. (Nothing, Nothing) -> throwString "You must allow either binary or source upgrade paths" (Just bo, Nothing) -> binary bo (Nothing, Just so) -> source so -- See #2977 - if --git or --git-repo is specified, do source upgrade. (_, Just so@(SourceOpts (Just _))) -> source so (Just bo, Just so) -> binary bo `catchAny` \e -> do prettyWarnL [ flow "Exception occured when trying to perform binary upgrade:" , fromString . show $ e , line <> flow "Falling back to source upgrade" ] source so where binary bo = binaryUpgrade bo source so = sourceUpgrade gConfigMonoid mresolver builtHash so binaryUpgrade :: HasConfig env => BinaryOpts -> RIO env () binaryUpgrade (BinaryOpts mplatform force' mver morg mrepo) = do platforms0 <- case mplatform of Nothing -> preferredPlatforms Just p -> return [("windows" `T.isInfixOf` T.pack p, p)] archiveInfo <- downloadStackReleaseInfo morg mrepo mver let mdownloadVersion = getDownloadVersion archiveInfo force = case mver of Nothing -> force' Just _ -> True -- specifying a version implies we're forcing things isNewer <- case mdownloadVersion of Nothing -> do prettyErrorL $ flow "Unable to determine upstream version from Github metadata" : [ line <> flow "Rerun with --force-download to force an upgrade" | not force] return False Just downloadVersion -> do prettyInfoL [ flow "Current Stack version:" , display stackVersion <> "," , flow "available download version:" , display downloadVersion ] return $ downloadVersion > stackVersion toUpgrade <- case (force, isNewer) of (False, False) -> do prettyInfoS "Skipping binary upgrade, you are already running the most recent version" return False (True, False) -> do prettyInfoS "Forcing binary upgrade" return True (_, True) -> do prettyInfoS "Newer version detected, downloading" return True when toUpgrade $ do config <- view configL downloadStackExe platforms0 archiveInfo (configLocalBin config) True $ \tmpFile -> do -- Sanity check! ec <- rawSystem (toFilePath tmpFile) ["--version"] unless (ec == ExitSuccess) $ throwString "Non-success exit code from running newly downloaded executable" sourceUpgrade :: HasConfig env => ConfigMonoid -> Maybe AbstractResolver -> Maybe String -> SourceOpts -> RIO env () sourceUpgrade gConfigMonoid mresolver builtHash (SourceOpts gitRepo) = withSystemTempDir "stack-upgrade" $ \tmp -> do mdir <- case gitRepo of Just (repo, branch) -> do remote <- liftIO $ System.Process.readProcess "git" ["ls-remote", repo, branch] [] latestCommit <- case words remote of [] -> throwString $ "No commits found for branch " ++ branch ++ " on repo " ++ repo x:_ -> return x when (isNothing builtHash) $ prettyWarnS $ "Information about the commit this version of stack was " <> "built from is not available due to how it was built. " <> "Will continue by assuming an upgrade is needed " <> "because we have no information to the contrary." if builtHash == Just latestCommit then do prettyInfoS "Already up-to-date, no upgrade required" return Nothing else do prettyInfoS "Cloning stack" -- NOTE: "--recursive" was added after v1.0.0 (and before the -- next release). This means that we can't use submodules in -- the stack repo until we're comfortable with "stack upgrade -- --git" not working for earlier versions. let args = [ "clone", repo , "stack", "--depth", "1", "--recursive", "--branch", branch] withWorkingDir (toFilePath tmp) $ proc "git" args runProcess_ #ifdef WINDOWS -- On Windows 10, an upstream issue with the `git clone` command -- means that command clears, but does not then restore, the -- ENABLE_VIRTUAL_TERMINAL_PROCESSING flag for native terminals. -- The folowing hack re-enables the lost ANSI-capability. _ <- liftIO defaultColorWhen #endif return $ Just $ tmp $(mkRelDir "stack") Nothing -> do updateAllIndices PackageCache caches <- getPackageCaches let versions = filter (/= $(mkVersion "9.9.9")) -- Mistaken upload to Hackage, just ignore it $ maybe [] HashMap.keys $ HashMap.lookup $(mkPackageName "stack") caches when (null versions) (throwString "No stack found in package indices") let version = Data.List.maximum versions if version <= fromCabalVersion (mkVersion' Paths.version) then do prettyInfoS "Already at latest version, no upgrade required" return Nothing else do let ident = PackageIdentifier $(mkPackageName "stack") version paths <- unpackPackageIdents tmp Nothing -- accept latest cabal revision [PackageIdentifierRevision ident CFILatest] case Map.lookup ident paths of Nothing -> error "Stack.Upgrade.upgrade: invariant violated, unpacked directory not found" Just path -> return $ Just path forM_ mdir $ \dir -> do lc <- loadConfig gConfigMonoid mresolver (SYLOverride $ dir $(mkRelFile "stack.yaml")) bconfig <- liftIO $ lcLoadBuildConfig lc Nothing envConfig1 <- runRIO bconfig $ setupEnv $ Just $ "Try rerunning with --install-ghc to install the correct GHC into " <> T.pack (toFilePath (configLocalPrograms (view configL bconfig))) runRIO (set (buildOptsL.buildOptsInstallExesL) True envConfig1) $ build (const $ return ()) Nothing defaultBuildOptsCLI { boptsCLITargets = ["stack"] } stack-1.9.3.1/src/Stack/Upload.hs0000644000000000000000000001675513455617610014620 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude #-} {-# LANGUAGE FlexibleContexts #-} {-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE ScopedTypeVariables #-} -- | Provide ability to upload tarballs to Hackage. module Stack.Upload ( -- * Upload upload , uploadBytes , uploadRevision -- * Credentials , HackageCreds , loadCreds ) where import Stack.Prelude import Data.Aeson (FromJSON (..), ToJSON (..), decode', encode, object, withObject, (.:), (.=)) import qualified Data.ByteString.Char8 as S import qualified Data.ByteString.Lazy as L import qualified Data.Conduit.Binary as CB import qualified Data.Text as T import Data.Text.Encoding (encodeUtf8) import Network.HTTP.StackClient (Request, RequestBody(RequestBodyLBS), Response, withResponse, httpNoBody, getGlobalManager, getResponseStatusCode, getResponseBody, setRequestHeader, parseRequest, formDataBody, partFileRequestBody, partBS, partLBS, applyDigestAuth, displayDigestAuthException) import Stack.Types.Config import Stack.Types.PackageIdentifier (PackageIdentifier, packageIdentifierString, packageIdentifierName) import Stack.Types.PackageName (packageNameString) import System.Directory (createDirectoryIfMissing, removeFile) import System.FilePath ((), takeFileName) import System.IO (stdout, putStrLn, putStr, print) -- TODO remove putStrLn, use logInfo -- | Username and password to log into Hackage. -- -- Since 0.1.0.0 data HackageCreds = HackageCreds { hcUsername :: !Text , hcPassword :: !Text , hcCredsFile :: !FilePath } deriving Show instance ToJSON HackageCreds where toJSON (HackageCreds u p _) = object [ "username" .= u , "password" .= p ] instance FromJSON (FilePath -> HackageCreds) where parseJSON = withObject "HackageCreds" $ \o -> HackageCreds <$> o .: "username" <*> o .: "password" -- | Load Hackage credentials, either from a save file or the command -- line. -- -- Since 0.1.0.0 loadCreds :: Config -> IO HackageCreds loadCreds config = do fp <- credsFile config elbs <- tryIO $ L.readFile fp case either (const Nothing) Just elbs >>= decode' of Nothing -> fromPrompt fp Just mkCreds -> do unless (configSaveHackageCreds config) $ do putStrLn "WARNING: You've set save-hackage-creds to false" putStrLn "However, credentials were found at:" putStrLn $ " " ++ fp return $ mkCreds fp where fromPrompt fp = do username <- prompt "Hackage username: " password <- promptPassword "Hackage password: " let hc = HackageCreds { hcUsername = username , hcPassword = password , hcCredsFile = fp } when (configSaveHackageCreds config) $ do shouldSave <- promptBool $ T.pack $ "Save hackage credentials to file at " ++ fp ++ " [y/n]? " putStrLn "NOTE: Avoid this prompt in the future by using: save-hackage-creds: false" when shouldSave $ do L.writeFile fp (encode hc) putStrLn "Saved!" hFlush stdout return hc credsFile :: Config -> IO FilePath credsFile config = do let dir = toFilePath (view stackRootL config) "upload" createDirectoryIfMissing True dir return $ dir "credentials.json" applyCreds :: HackageCreds -> Request -> IO Request applyCreds creds req0 = do manager <- getGlobalManager ereq <- applyDigestAuth (encodeUtf8 $ hcUsername creds) (encodeUtf8 $ hcPassword creds) req0 manager case ereq of Left e -> do putStrLn "WARNING: No HTTP digest prompt found, this will probably fail" case fromException e of Just e' -> putStrLn $ displayDigestAuthException e' Nothing -> print e return req0 Right req -> return req -- | Upload a single tarball with the given @Uploader@. Instead of -- sending a file like 'upload', this sends a lazy bytestring. -- -- Since 0.1.2.1 uploadBytes :: String -- ^ Hackage base URL -> HackageCreds -> String -- ^ tar file name -> L.ByteString -- ^ tar file contents -> IO () uploadBytes baseUrl creds tarName bytes = do let req1 = setRequestHeader "Accept" ["text/plain"] (fromString $ baseUrl <> "packages/") formData = [partFileRequestBody "package" tarName (RequestBodyLBS bytes)] req2 <- formDataBody formData req1 req3 <- applyCreds creds req2 putStr $ "Uploading " ++ tarName ++ "... " hFlush stdout withResponse req3 $ \res -> case getResponseStatusCode res of 200 -> putStrLn "done!" 401 -> do putStrLn "authentication failure" handleIO (const $ return ()) (removeFile (hcCredsFile creds)) throwString "Authentication failure uploading to server" 403 -> do putStrLn "forbidden upload" putStrLn "Usually means: you've already uploaded this package/version combination" putStrLn "Ignoring error and continuing, full message from Hackage below:\n" printBody res 503 -> do putStrLn "service unavailable" putStrLn "This error some times gets sent even though the upload succeeded" putStrLn "Check on Hackage to see if your pacakge is present" printBody res code -> do putStrLn $ "unhandled status code: " ++ show code printBody res throwString $ "Upload failed on " ++ tarName printBody :: Response (ConduitM () S.ByteString IO ()) -> IO () printBody res = runConduit $ getResponseBody res .| CB.sinkHandle stdout -- | Upload a single tarball with the given @Uploader@. -- -- Since 0.1.0.0 upload :: String -- ^ Hackage base URL -> HackageCreds -> FilePath -> IO () upload baseUrl creds fp = uploadBytes baseUrl creds (takeFileName fp) =<< L.readFile fp uploadRevision :: String -- ^ Hackage base URL -> HackageCreds -> PackageIdentifier -> L.ByteString -> IO () uploadRevision baseUrl creds ident cabalFile = do req0 <- parseRequest $ concat [ baseUrl , "package/" , packageIdentifierString ident , "/" , packageNameString $ packageIdentifierName ident , ".cabal/edit" ] req1 <- formDataBody [ partLBS "cabalfile" cabalFile , partBS "publish" "on" ] req0 req2 <- applyCreds creds req1 void $ httpNoBody req2 stack-1.9.3.1/src/Text/PrettyPrint/Leijen/Extended.hs0000644000000000000000000002554713455671116020525 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude #-} {-# OPTIONS_GHC -fno-warn-orphans #-} {-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE FlexibleContexts #-} {-# LANGUAGE RankNTypes #-} {-# LANGUAGE DefaultSignatures #-} {-# LANGUAGE TypeFamilies #-} {-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE GeneralizedNewtypeDeriving #-} {-# LANGUAGE MultiParamTypeClasses #-} {-# LANGUAGE UndecidableInstances #-} -- | This module re-exports some of the interface for -- "Text.PrettyPrint.Annotated.Leijen" along with additional definitions -- useful for stack. -- -- It defines a 'Monoid' instance for 'Doc'. module Text.PrettyPrint.Leijen.Extended ( -- * Pretty-print typeclass Display(..), -- * Ansi terminal Doc -- -- See "System.Console.ANSI" for 'SGR' values to use beyond the colors -- provided. AnsiDoc, AnsiAnn(..), HasAnsiAnn(..), hDisplayAnsi, displayAnsi, displayPlain, renderDefault, -- ** Color combinators black, red, green, yellow, blue, magenta, cyan, white, dullblack, dullred, dullgreen, dullyellow, dullblue, dullmagenta, dullcyan, dullwhite, onblack, onred, ongreen, onyellow, onblue, onmagenta, oncyan, onwhite, ondullblack, ondullred, ondullgreen, ondullyellow, ondullblue, ondullmagenta, ondullcyan, ondullwhite, -- ** Intensity combinators bold, faint, normal, -- * Selective re-exports from "Text.PrettyPrint.Annotated.Leijen" -- -- Documentation of omissions up-to-date with @annotated-wl-pprint-0.7.0@ -- ** Documents, parametrized by their annotations -- -- Omitted compared to original: @putDoc, hPutDoc@ Doc, -- ** Basic combinators -- -- Omitted compared to original: @empty, char, text, (<>)@ -- -- Instead of @text@ and @char@, use 'fromString'. -- -- Instead of @empty@, use 'mempty'. nest, line, linebreak, group, softline, softbreak, -- ** Alignment -- -- The combinators in this section can not be described by Wadler's -- original combinators. They align their output relative to the -- current output position - in contrast to @nest@ which always -- aligns to the current nesting level. This deprives these -- combinators from being \`optimal\'. In practice however they -- prove to be very useful. The combinators in this section should -- be used with care, since they are more expensive than the other -- combinators. For example, @align@ shouldn't be used to pretty -- print all top-level declarations of a language, but using @hang@ -- for let expressions is fine. -- -- Omitted compared to original: @list, tupled, semiBraces@ align, hang, indent, encloseSep, -- ** Operators -- -- Omitted compared to original: @(<$>), (), (<$$>), ()@ (<+>), -- ** List combinators hsep, vsep, fillSep, sep, hcat, vcat, fillCat, cat, punctuate, -- ** Fillers fill, fillBreak, -- ** Bracketing combinators enclose, squotes, dquotes, parens, angles, braces, brackets, -- ** Character documents -- Entirely omitted: -- -- @ -- lparen, rparen, langle, rangle, lbrace, rbrace, lbracket, rbracket, -- squote, dquote, semi, colon, comma, space, dot, backslash, equals, -- pipe -- @ -- ** Primitive type documents -- Entirely omitted: -- -- @ -- string, int, integer, float, double, rational, bool, -- @ -- ** Semantic annotations annotate, noAnnotate, -- ** Rendering -- Original entirely omitted: -- @ -- SimpleDoc(..), renderPretty, renderCompact, displayDecorated, displayDecoratedA, display, displayS, displayIO, -- SpanList(..), displaySpans -- @ -- ** Undocumented -- Entirely omitted: -- @ -- column, nesting, width -- @ ) where import Control.Monad.Reader (runReader, local) import qualified Data.Map.Strict as M import qualified Data.Text as T import qualified Data.Text.IO as T import qualified Data.Text.Lazy as LT import qualified Data.Text.Lazy.Builder as LTB import Stack.Prelude hiding (Display (..)) import System.Console.ANSI (Color(..), ColorIntensity(..), ConsoleLayer(..), ConsoleIntensity(..), SGR(..), setSGRCode, hSupportsANSI) import qualified Text.PrettyPrint.Annotated.Leijen as P import Text.PrettyPrint.Annotated.Leijen hiding ((<>), display) -- TODO: consider smashing together the code for wl-annotated-pprint and -- wl-pprint-text. The code here already handles doing the -- ansi-wl-pprint stuff (better!) atop wl-annotated-pprint. So the -- result would be a package unifying 3 different wl inspired packages. -- -- Perhaps it can still have native string support, by adding a type -- parameter to Doc? instance Semigroup (Doc a) where (<>) = (P.<>) instance Monoid (Doc a) where mappend = (<>) mempty = empty -------------------------------------------------------------------------------- -- Pretty-Print class class Display a where type Ann a type Ann a = AnsiAnn display :: a -> Doc (Ann a) default display :: Show a => a -> Doc (Ann a) display = fromString . show instance Display (Doc a) where type Ann (Doc a) = a display = id -------------------------------------------------------------------------------- -- Ansi Doc type AnsiDoc = Doc AnsiAnn newtype AnsiAnn = AnsiAnn [SGR] deriving (Eq, Show, Semigroup, Monoid) class HasAnsiAnn a where getAnsiAnn :: a -> AnsiAnn toAnsiDoc :: Doc a -> AnsiDoc toAnsiDoc = fmap getAnsiAnn instance HasAnsiAnn AnsiAnn where getAnsiAnn = id toAnsiDoc = id instance HasAnsiAnn () where getAnsiAnn _ = mempty displayPlain :: Display a => Int -> a -> T.Text displayPlain w = LT.toStrict . displayAnsiSimple . renderDefault w . fmap (const mempty) . display -- TODO: tweak these settings more? -- TODO: options for settings if this is released as a lib renderDefault :: Int -> Doc a -> SimpleDoc a renderDefault = renderPretty 1 displayAnsi :: (Display a, HasAnsiAnn (Ann a)) => Int -> a -> T.Text displayAnsi w = LT.toStrict . displayAnsiSimple . renderDefault w . toAnsiDoc . display hDisplayAnsi :: (Display a, HasAnsiAnn (Ann a), MonadIO m) => Handle -> Int -> a -> m () hDisplayAnsi h w x = liftIO $ do useAnsi <- hSupportsANSI h T.hPutStr h $ if useAnsi then displayAnsi w x else displayPlain w x displayAnsiSimple :: SimpleDoc AnsiAnn -> LT.Text displayAnsiSimple doc = LTB.toLazyText $ flip runReader mempty $ displayDecoratedWrap go doc where go (AnsiAnn sgrs) inner = do old <- ask let sgrs' = mapMaybe (\sgr -> if sgr == Reset then Nothing else Just (getSGRTag sgr, sgr)) sgrs new = if Reset `elem` sgrs then M.fromList sgrs' else foldl' (\mp (tag, sgr) -> M.insert tag sgr mp) old sgrs' (extra, contents) <- local (const new) inner return (extra, transitionCodes old new <> contents <> transitionCodes new old) transitionCodes old new = case (null removals, null additions) of (True, True) -> mempty (True, False) -> fromString (setSGRCode additions) (False, _) -> fromString (setSGRCode (Reset : M.elems new)) where (removals, additions) = partitionEithers $ M.elems $ M.mergeWithKey (\_ o n -> if o == n then Nothing else Just (Right n)) (fmap Left) (fmap Right) old new displayDecoratedWrap :: forall a m. Monad m => (forall b. a -> m (b, LTB.Builder) -> m (b, LTB.Builder)) -> SimpleDoc a -> m LTB.Builder displayDecoratedWrap f doc = do (mafter, result) <- go doc case mafter of Just _ -> error "Invariant violated by input to displayDecoratedWrap: no matching SAnnotStart for SAnnotStop." Nothing -> return result where spaces n = LTB.fromText (T.replicate n " ") go :: SimpleDoc a -> m (Maybe (SimpleDoc a), LTB.Builder) go SEmpty = return (Nothing, mempty) go (SChar c x) = liftM (fmap (LTB.singleton c <>)) (go x) -- NOTE: Could actually use the length to guess at an initial -- allocation. Better yet would be to just use Text in pprint.. go (SText _l s x) = liftM (fmap (fromString s <>)) (go x) go (SLine n x) = liftM (fmap ((LTB.singleton '\n' <>) . (spaces n <>))) (go x) go (SAnnotStart ann x) = do (mafter, contents) <- f ann (go x) case mafter of Just after -> liftM (fmap (contents <>)) (go after) Nothing -> error "Invariant violated by input to displayDecoratedWrap: no matching SAnnotStop for SAnnotStart." go (SAnnotStop x) = return (Just x, mempty) -- Foreground color combinators black, red, green, yellow, blue, magenta, cyan, white, dullblack, dullred, dullgreen, dullyellow, dullblue, dullmagenta, dullcyan, dullwhite, onblack, onred, ongreen, onyellow, onblue, onmagenta, oncyan, onwhite, ondullblack, ondullred, ondullgreen, ondullyellow, ondullblue, ondullmagenta, ondullcyan, ondullwhite :: Doc AnsiAnn -> Doc AnsiAnn (black, dullblack, onblack, ondullblack) = colorFunctions Black (red, dullred, onred, ondullred) = colorFunctions Red (green, dullgreen, ongreen, ondullgreen) = colorFunctions Green (yellow, dullyellow, onyellow, ondullyellow) = colorFunctions Yellow (blue, dullblue, onblue, ondullblue) = colorFunctions Blue (magenta, dullmagenta, onmagenta, ondullmagenta) = colorFunctions Magenta (cyan, dullcyan, oncyan, ondullcyan) = colorFunctions Cyan (white, dullwhite, onwhite, ondullwhite) = colorFunctions White type EndoAnsiDoc = Doc AnsiAnn -> Doc AnsiAnn colorFunctions :: Color -> (EndoAnsiDoc, EndoAnsiDoc, EndoAnsiDoc, EndoAnsiDoc) colorFunctions color = ( ansiAnn [SetColor Foreground Vivid color] , ansiAnn [SetColor Foreground Dull color] , ansiAnn [SetColor Background Vivid color] , ansiAnn [SetColor Background Dull color] ) ansiAnn :: [SGR] -> Doc AnsiAnn -> Doc AnsiAnn ansiAnn = annotate . AnsiAnn -- Intensity combinators bold, faint, normal :: Doc AnsiAnn -> Doc AnsiAnn bold = ansiAnn [SetConsoleIntensity BoldIntensity] faint = ansiAnn [SetConsoleIntensity FaintIntensity] normal = ansiAnn [SetConsoleIntensity NormalIntensity] -- | Tags for each field of state in SGR (Select Graphics Rendition). -- -- It's a bit of a hack that 'TagReset' is included. data SGRTag = TagReset | TagConsoleIntensity | TagItalicized | TagUnderlining | TagBlinkSpeed | TagVisible | TagSwapForegroundBackground | TagColorForeground | TagColorBackground | TagRGBColor deriving (Eq, Ord) getSGRTag :: SGR -> SGRTag getSGRTag Reset{} = TagReset getSGRTag SetConsoleIntensity{} = TagConsoleIntensity getSGRTag SetItalicized{} = TagItalicized getSGRTag SetUnderlining{} = TagUnderlining getSGRTag SetBlinkSpeed{} = TagBlinkSpeed getSGRTag SetVisible{} = TagVisible getSGRTag SetSwapForegroundBackground{} = TagSwapForegroundBackground getSGRTag (SetColor Foreground _ _) = TagColorForeground getSGRTag (SetColor Background _ _) = TagColorBackground getSGRTag SetRGBColor{} = TagRGBColor stack-1.9.3.1/src/System/Process/PagerEditor.hs0000644000000000000000000001165613455617610017431 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude #-} {-# LANGUAGE ScopedTypeVariables, RankNTypes, DeriveDataTypeable #-} -- | Run external pagers (@$PAGER@, @less@, @more@) and editors (@$VISUAL@, -- @$EDITOR@, @nano@, @pico@, @vi@). module System.Process.PagerEditor (-- * Pager pageWriter ,pageByteString ,pageText ,pageBuilder ,pageFile ,pageString ,PagerException(..) -- * Editor ,editFile ,editReaderWriter ,editByteString ,editString ,EditorException(..)) where import qualified Data.ByteString.Lazy (readFile) import Data.ByteString.Lazy (hPut) import Stack.Prelude import System.Directory (findExecutable) import System.Environment (lookupEnv) import System.Exit (ExitCode(..)) import System.FilePath (()) import System.Process (createProcess,shell,proc,waitForProcess,StdStream (CreatePipe) ,CreateProcess(std_in, close_fds, delegate_ctlc)) import System.IO (hPutStr,readFile,stdout) import qualified Data.Text.IO as T -- | Run pager, providing a function that writes to the pager's input. pageWriter :: (Handle -> IO ()) -> IO () pageWriter writer = do mpager <- lookupEnv "PAGER" `orElse` findExecutable "less" `orElse` findExecutable "more" case mpager of Just pager -> do (Just h,_,_,procHandle) <- createProcess (shell pager) {std_in = CreatePipe ,close_fds = True ,delegate_ctlc = True} (_::Either IOException ()) <- try (do writer h hClose h) exit <- waitForProcess procHandle case exit of ExitSuccess -> return () ExitFailure n -> throwIO (PagerExitFailure pager n) return () Nothing -> writer stdout -- | Run pager to display a lazy ByteString. pageByteString :: LByteString -> IO () pageByteString = pageWriter . flip hPut -- | Run pager to display a 'Text' pageText :: Text -> IO () pageText = pageWriter . flip T.hPutStr -- | Run pager to display a ByteString-Builder. pageBuilder :: Builder -> IO () pageBuilder = pageWriter . flip hPutBuilder -- | Run pager to display contents of a file. pageFile :: FilePath -> IO () pageFile p = pageByteString =<< Data.ByteString.Lazy.readFile p -- | Run pager to display a string. pageString :: String -> IO () pageString = pageBuilder . fromString -- | Run editor to edit a file. editFile :: FilePath -> IO () editFile path = do meditor <- lookupEnv "VISUAL" `orElse` lookupEnv "EDITOR" `orElse` findExecutable "nano" `orElse` findExecutable "pico" `orElse` findExecutable "vi" case meditor of Just editor -> do (_,_,_,procHandle) <- createProcess (proc "sh" ["-c", editor ++ " \"$1\"", "sh", path]) {close_fds = True,delegate_ctlc = True} exitCode <- waitForProcess procHandle case exitCode of ExitSuccess -> return () ExitFailure n -> throwIO (EditorExitFailure editor n) Nothing -> throwIO EditorNotFound -- | Run editor, providing functions to write and read the file contents. editReaderWriter :: forall a. String -> (Handle -> IO ()) -> (FilePath -> IO a) -> IO a editReaderWriter filename writer reader = withSystemTempDirectory "" (\p -> do let p' = p filename withFile p' WriteMode writer editFile p' reader p') -- | Run editor on a ByteString. editByteString :: String -> LByteString -> IO LByteString editByteString f s = editReaderWriter f (`hPut` s) Data.ByteString.Lazy.readFile -- | Run editor on a String. editString :: String -> String -> IO String editString f s = editReaderWriter f (`hPutStr` s) System.IO.readFile -- | Short-circuit first Just. orElse :: (Monad m) => m (Maybe a) -> m (Maybe a) -> m (Maybe a) orElse a b = do m <- a case m of Just _ -> return m Nothing -> b -- | Exception running pager. data PagerException = PagerNotFound | PagerExitFailure FilePath Int deriving Typeable instance Show PagerException where show PagerNotFound = "No pager found (tried $PAGER, `less`, and `more`.)" show (PagerExitFailure p n) = "Pager (`" ++ p ++ "') exited with non-zero status: " ++ show n instance Exception PagerException -- | Exception running editor. data EditorException = EditorNotFound | EditorExitFailure FilePath Int deriving Typeable instance Show EditorException where show EditorNotFound = "No editor found (tried $VISUAL, $PAGER, `nano`, `pico`, and `vi`.)" show (EditorExitFailure p n) = "Editor (`" ++ p ++ "') exited with non-zero status: " ++ show n instance Exception EditorException stack-1.9.3.1/src/windows/System/Terminal.hs0000644000000000000000000000026213455617610017042 0ustar0000000000000000module System.Terminal ( getTerminalWidth ) where -- | Get the width, in columns, of the terminal if we can. getTerminalWidth :: IO (Maybe Int) getTerminalWidth = return Nothing stack-1.9.3.1/src/unix/System/Terminal.hsc0000644000000000000000000000165213455617610016502 0ustar0000000000000000{-# LANGUAGE ForeignFunctionInterface #-} module System.Terminal ( getTerminalWidth ) where import Foreign import Foreign.C.Types #include #include newtype WindowWidth = WindowWidth CUShort deriving (Eq, Ord, Show) instance Storable WindowWidth where sizeOf _ = (#size struct winsize) alignment _ = (#alignment struct winsize) peek p = WindowWidth <$> (#peek struct winsize, ws_col) p poke p (WindowWidth w) = do (#poke struct winsize, ws_col) p w foreign import ccall "sys/ioctl.h ioctl" ioctl :: CInt -> CInt -> Ptr WindowWidth -> IO CInt -- | Get the width, in columns, of the terminal if we can. getTerminalWidth :: IO (Maybe Int) getTerminalWidth = alloca $ \p -> do errno <- ioctl (#const STDOUT_FILENO) (#const TIOCGWINSZ) p if errno < 0 then return Nothing else do WindowWidth w <- peek p return . Just . fromIntegral $ w stack-1.9.3.1/src/Hackage/Security/Client/Repository/HttpLib/HttpClient.hs0000644000000000000000000001435013455617610024467 0ustar0000000000000000-- Explicitly disabling due to external code {-# LANGUAGE NoImplicitPrelude #-} {-# LANGUAGE FlexibleContexts #-} {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE RankNTypes #-} {-# LANGUAGE ScopedTypeVariables #-} -- Taken from -- https://github.com/well-typed/hackage-security/tree/master/hackage-security-http-client -- to avoid extra dependencies module Hackage.Security.Client.Repository.HttpLib.HttpClient ( makeHttpLib -- ** Re-exports , Manager -- opaque ) where import Control.Exception import Control.Monad (void) import Data.ByteString (ByteString) import Network.URI import qualified Data.ByteString as BS import qualified Data.ByteString.Char8 as BS.C8 import Network.HTTP.StackClient (Manager) import qualified Network.HTTP.StackClient as StackClient import Hackage.Security.Client hiding (Header) import Hackage.Security.Client.Repository.HttpLib import Hackage.Security.Util.Checked import qualified Hackage.Security.Util.Lens as Lens {------------------------------------------------------------------------------- Top-level API -------------------------------------------------------------------------------} -- | Create an 'HttpLib' value from a preexisting 'Manager'. makeHttpLib :: Manager -> HttpLib makeHttpLib manager = HttpLib { httpGet = get manager , httpGetRange = getRange manager } {------------------------------------------------------------------------------- Individual methods -------------------------------------------------------------------------------} get :: Throws SomeRemoteError => Manager -> [HttpRequestHeader] -> URI -> ([HttpResponseHeader] -> BodyReader -> IO a) -> IO a get manager reqHeaders uri callback = wrapCustomEx $ do -- TODO: setUri fails under certain circumstances; in particular, when -- the URI contains URL auth. Not sure if this is a concern. request' <- StackClient.setUri StackClient.defaultRequest uri let request = setRequestHeaders reqHeaders request' checkHttpException $ StackClient.withResponseByManager request manager $ \response -> do let br = wrapCustomEx $ StackClient.responseBody response callback (getResponseHeaders response) br getRange :: Throws SomeRemoteError => Manager -> [HttpRequestHeader] -> URI -> (Int, Int) -> (HttpStatus -> [HttpResponseHeader] -> BodyReader -> IO a) -> IO a getRange manager reqHeaders uri (from, to) callback = wrapCustomEx $ do request' <- StackClient.setUri StackClient.defaultRequest uri let request = setRange from to $ setRequestHeaders reqHeaders request' checkHttpException $ StackClient.withResponseByManager request manager $ \response -> do let br = wrapCustomEx $ StackClient.responseBody response case () of () | StackClient.responseStatus response == StackClient.partialContent206 -> callback HttpStatus206PartialContent (getResponseHeaders response) br () | StackClient.responseStatus response == StackClient.ok200 -> callback HttpStatus200OK (getResponseHeaders response) br _otherwise -> throwChecked $ StackClient.HttpExceptionRequest request $ StackClient.StatusCodeException (void response) "" -- | Wrap custom exceptions -- -- NOTE: The only other exception defined in @http-client@ is @TimeoutTriggered@ -- but it is currently disabled wrapCustomEx :: (Throws StackClient.HttpException => IO a) -> (Throws SomeRemoteError => IO a) wrapCustomEx act = handleChecked (\(ex :: StackClient.HttpException) -> go ex) act where go ex = throwChecked (SomeRemoteError ex) checkHttpException :: Throws StackClient.HttpException => IO a -> IO a checkHttpException = handle $ \(ex :: StackClient.HttpException) -> throwChecked ex {------------------------------------------------------------------------------- http-client auxiliary -------------------------------------------------------------------------------} hAcceptRanges :: StackClient.HeaderName hAcceptRanges = "Accept-Ranges" hAcceptEncoding :: StackClient.HeaderName hAcceptEncoding = "Accept-Encoding" setRange :: Int -> Int -> StackClient.Request -> StackClient.Request setRange from to req = req { StackClient.requestHeaders = (StackClient.hRange, rangeHeader) : StackClient.requestHeaders req } where -- Content-Range header uses inclusive rather than exclusive bounds -- See rangeHeader = BS.C8.pack $ "bytes=" ++ show from ++ "-" ++ show (to - 1) -- | Set request headers setRequestHeaders :: [HttpRequestHeader] -> StackClient.Request -> StackClient.Request setRequestHeaders opts req = req { StackClient.requestHeaders = trOpt disallowCompressionByDefault opts } where trOpt :: [(StackClient.HeaderName, [ByteString])] -> [HttpRequestHeader] -> [StackClient.Header] trOpt acc [] = concatMap finalizeHeader acc trOpt acc (HttpRequestMaxAge0:os) = trOpt (insert StackClient.hCacheControl ["max-age=0"] acc) os trOpt acc (HttpRequestNoTransform:os) = trOpt (insert StackClient.hCacheControl ["no-transform"] acc) os -- disable content compression (potential security issue) disallowCompressionByDefault :: [(StackClient.HeaderName, [ByteString])] disallowCompressionByDefault = [(hAcceptEncoding, [])] -- Some headers are comma-separated, others need multiple headers for -- multiple options. -- -- TODO: Right we we just comma-separate all of them. finalizeHeader :: (StackClient.HeaderName, [ByteString]) -> [StackClient.Header] finalizeHeader (name, strs) = [(name, BS.intercalate ", " (reverse strs))] insert :: Eq a => a -> [b] -> [(a, [b])] -> [(a, [b])] insert x y = Lens.modify (Lens.lookupM x) (++ y) -- | Extract the response headers getResponseHeaders :: StackClient.Response a -> [HttpResponseHeader] getResponseHeaders response = concat [ [ HttpResponseAcceptRangesBytes | (hAcceptRanges, "bytes") `elem` headers ] ] where headers = StackClient.responseHeaders response stack-1.9.3.1/src/main/Main.hs0000644000000000000000000012462213455671116014131 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude #-} {-# LANGUAGE CPP #-} {-# LANGUAGE DeriveDataTypeable #-} {-# LANGUAGE FlexibleContexts #-} {-# LANGUAGE GADTs #-} {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE RecordWildCards #-} #ifdef USE_GIT_INFO {-# LANGUAGE TemplateHaskell #-} #endif -- | Main stack tool entry point. module Main (main) where #ifndef HIDE_DEP_VERSIONS import qualified Build_stack #endif import Stack.Prelude hiding (Display (..)) import Control.Monad.Reader (local) import Control.Monad.Trans.Except (ExceptT) import Control.Monad.Writer.Lazy (Writer) import Data.Attoparsec.Args (parseArgs, EscapingMode (Escaping)) import Data.Attoparsec.Interpreter (getInterpreterArgs) import qualified Data.ByteString.Lazy as L import Data.IORef.RunOnce (runOnce) import Data.List import qualified Data.Map.Strict as Map import qualified Data.Set as Set import qualified Data.Text as T import Data.Version (showVersion) import RIO.Process #ifdef USE_GIT_INFO import GitHash (giCommitCount, giHash, tGitInfoCwdTry) #endif import Distribution.System (buildArch) import qualified Distribution.Text as Cabal (display) import Distribution.Version (mkVersion') import GHC.IO.Encoding (mkTextEncoding, textEncodingName) import Options.Applicative import Options.Applicative.Help (errorHelp, stringChunk, vcatChunks) import Options.Applicative.Builder.Extra import Options.Applicative.Complicated #ifdef USE_GIT_INFO import Options.Applicative.Simple (simpleVersion) #endif import Options.Applicative.Types (ParserHelp(..)) import Path import Path.IO import qualified Paths_stack as Meta import Stack.Build import Stack.Clean (CleanOpts(..), clean) import Stack.Config import Stack.ConfigCmd as ConfigCmd import Stack.Constants import Stack.Constants.Config import Stack.Coverage import Stack.DefaultColorWhen (defaultColorWhen) import qualified Stack.Docker as Docker import Stack.Dot import Stack.GhcPkg (findGhcPkgField) import qualified Stack.Nix as Nix import Stack.Fetch import Stack.FileWatch import Stack.Ghci import Stack.Hoogle import Stack.Ls import qualified Stack.IDE as IDE import qualified Stack.Image as Image import Stack.Init import Stack.New import Stack.Options.BuildParser import Stack.Options.CleanParser import Stack.Options.DockerParser import Stack.Options.DotParser import Stack.Options.ExecParser import Stack.Options.GhciParser import Stack.Options.GlobalParser import Stack.Options.HpcReportParser import Stack.Options.NewParser import Stack.Options.NixParser import Stack.Options.ScriptParser import Stack.Options.SDistParser import Stack.Options.SolverParser import Stack.Options.Utils import qualified Stack.PackageIndex import qualified Stack.Path import Stack.PrettyPrint import Stack.Runners import Stack.Script import Stack.SDist (getSDistTarball, checkSDistTarball, checkSDistTarball', SDistOpts(..)) import Stack.SetupCmd import qualified Stack.Sig as Sig import Stack.Snapshot (loadResolver) import Stack.Solver (solveExtraDeps) import Stack.Types.Version import Stack.Types.Config import Stack.Types.Compiler import Stack.Types.NamedComponent import Stack.Types.Nix import Stack.Upgrade import qualified Stack.Upload as Upload import qualified System.Directory as D import System.Environment (getProgName, getArgs, withArgs) import System.Exit import System.FilePath (isValid, pathSeparator) import qualified System.FilePath as FP import System.IO (stderr, stdin, stdout, BufferMode(..), hPutStrLn, hPrint, hGetEncoding, hSetEncoding) -- | Change the character encoding of the given Handle to transliterate -- on unsupported characters instead of throwing an exception hSetTranslit :: Handle -> IO () hSetTranslit h = do menc <- hGetEncoding h case fmap textEncodingName menc of Just name | '/' `notElem` name -> do enc' <- mkTextEncoding $ name ++ "//TRANSLIT" hSetEncoding h enc' _ -> return () versionString' :: String #ifdef USE_GIT_INFO versionString' = concat $ concat [ [$(simpleVersion Meta.version)] -- Leave out number of commits for --depth=1 clone -- See https://github.com/commercialhaskell/stack/issues/792 , case giCommitCount <$> $$tGitInfoCwdTry of Left _ -> [] Right 1 -> [] Right count -> [" (", show count, " commits)"] , [" ", Cabal.display buildArch] , [depsString, warningString] ] #else versionString' = showVersion Meta.version ++ ' ' : Cabal.display buildArch ++ depsString ++ warningString #endif where #ifdef HIDE_DEP_VERSIONS depsString = " hpack-" ++ VERSION_hpack #else depsString = "\nCompiled with:\n" ++ unlines (map ("- " ++) Build_stack.deps) #endif #ifdef SUPPORTED_BUILD warningString = "" #else warningString = unlines [ "" , "Warning: this is an unsupported build that may use different versions of" , "dependencies and GHC than the officially released binaries, and therefore may" , "not behave identically. If you encounter problems, please try the latest" , "official build by running 'stack upgrade --force-download'." ] #endif main :: IO () main = do -- Line buffer the output by default, particularly for non-terminal runs. -- See https://github.com/commercialhaskell/stack/pull/360 hSetBuffering stdout LineBuffering hSetBuffering stdin LineBuffering hSetBuffering stderr LineBuffering hSetTranslit stdout hSetTranslit stderr args <- getArgs progName <- getProgName isTerminal <- hIsTerminalDeviceOrMinTTY stdout -- On Windows, where applicable, defaultColorWhen has the side effect of -- enabling ANSI for ANSI-capable native (ConHost) terminals, if not already -- ANSI-enabled. defColorWhen <- defaultColorWhen execExtraHelp args Docker.dockerHelpOptName (dockerOptsParser False) ("Only showing --" ++ Docker.dockerCmdName ++ "* options.") execExtraHelp args Nix.nixHelpOptName (nixOptsParser False) ("Only showing --" ++ Nix.nixCmdName ++ "* options.") currentDir <- D.getCurrentDirectory eGlobalRun <- try $ commandLineHandler currentDir progName False case eGlobalRun of Left (exitCode :: ExitCode) -> throwIO exitCode Right (globalMonoid,run) -> do let global = globalOptsFromMonoid isTerminal defColorWhen globalMonoid when (globalLogLevel global == LevelDebug) $ hPutStrLn stderr versionString' case globalReExecVersion global of Just expectVersion -> do expectVersion' <- parseVersionFromString expectVersion unless (checkVersion MatchMinor expectVersion' (fromCabalVersion (mkVersion' Meta.version))) $ throwIO $ InvalidReExecVersion expectVersion (showVersion Meta.version) _ -> return () run global `catch` \e -> -- This special handler stops "stack: " from being printed before the -- exception case fromException e of Just ec -> System.Exit.exitWith ec Nothing -> do hPrint stderr e System.Exit.exitFailure -- Vertically combine only the error component of the first argument with the -- error component of the second. vcatErrorHelp :: ParserHelp -> ParserHelp -> ParserHelp vcatErrorHelp h1 h2 = h2 { helpError = vcatChunks [helpError h2, helpError h1] } commandLineHandler :: FilePath -> String -> Bool -> IO (GlobalOptsMonoid, GlobalOpts -> IO ()) commandLineHandler currentDir progName isInterpreter = complicatedOptions Meta.version (Just versionString') VERSION_hpack "stack - The Haskell Tool Stack" "" "stack's documentation is available at https://docs.haskellstack.org/" (globalOpts OuterGlobalOpts) (Just failureCallback) addCommands where failureCallback f args = case stripPrefix "Invalid argument" (fst (renderFailure f "")) of Just _ -> if isInterpreter then parseResultHandler args f else secondaryCommandHandler args f >>= interpreterHandler currentDir args Nothing -> parseResultHandler args f parseResultHandler args f = if isInterpreter then do let hlp = errorHelp $ stringChunk (unwords ["Error executing interpreter command:" , progName , unwords args]) handleParseResult (overFailure (vcatErrorHelp hlp) (Failure f)) else handleParseResult (Failure f) addCommands = do unless isInterpreter (do addBuildCommand' "build" "Build the package(s) in this directory/configuration" buildCmd (buildOptsParser Build) addBuildCommand' "install" "Shortcut for 'build --copy-bins'" buildCmd (buildOptsParser Install) addCommand' "uninstall" "DEPRECATED: This command performs no actions, and is present for documentation only" uninstallCmd (many $ strArgument $ metavar "IGNORED") addBuildCommand' "test" "Shortcut for 'build --test'" buildCmd (buildOptsParser Test) addBuildCommand' "bench" "Shortcut for 'build --bench'" buildCmd (buildOptsParser Bench) addBuildCommand' "haddock" "Shortcut for 'build --haddock'" buildCmd (buildOptsParser Haddock) addCommand' "new" (unwords [ "Create a new project from a template." , "Run `stack templates' to see available templates." , "Note: you can also specify a local file or a" , "remote URL as a template." ] ) newCmd newOptsParser addCommand' "templates" (unwords [ "List the templates available for `stack new'." , "Templates are drawn from" , "https://github.com/commercialhaskell/stack-templates" , "Note: `stack new' can also accept a template from a" , "local file or a remote URL." ] ) templatesCmd (pure ()) addCommand' "init" "Create stack project config from cabal or hpack package specifications" initCmd initOptsParser addCommand' "solver" "Add missing extra-deps to stack project config" solverCmd solverOptsParser addCommand' "setup" "Get the appropriate GHC for your project" setupCmd setupParser addCommand' "path" "Print out handy path information" pathCmd Stack.Path.pathParser addCommand' "ls" "List command. (Supports snapshots and dependencies)" lsCmd lsParser addCommand' "unpack" "Unpack one or more packages locally" unpackCmd ((,) <$> some (strArgument $ metavar "PACKAGE") <*> optional (textOption $ long "to" <> help "Optional path to unpack the package into (will unpack into subdirectory)")) addCommand' "update" "Update the package index" updateCmd (pure ()) addCommand' "upgrade" "Upgrade to the latest stack" upgradeCmd upgradeOpts addCommand' "upload" "Upload a package to Hackage" uploadCmd (sdistOptsParser True) addCommand' "sdist" "Create source distribution tarballs" sdistCmd (sdistOptsParser False) addCommand' "dot" "Visualize your project's dependency graph using Graphviz dot" dotCmd (dotOptsParser False) -- Default for --external is False. addCommand' "ghc" "Run ghc" execCmd (execOptsParser $ Just ExecGhc) addCommand' "hoogle" ("Run hoogle, the Haskell API search engine. Use 'stack exec' syntax " ++ "to pass Hoogle arguments, e.g. stack hoogle -- --count=20 or " ++ "stack hoogle -- server --local") hoogleCmd ((,,,) <$> many (strArgument (metavar "ARG")) <*> boolFlags True "setup" "If needed: install hoogle, build haddocks and generate a hoogle database" idm <*> switch (long "rebuild" <> help "Rebuild the hoogle database") <*> switch (long "server" <> help "Start local Hoogle server")) ) -- These are the only commands allowed in interpreter mode as well addCommand' "exec" "Execute a command" execCmd (execOptsParser Nothing) addCommand' "run" "Build and run an executable. Defaults to the first available executable if none is provided as the first argument." execCmd (execOptsParser $ Just ExecRun) addGhciCommand' "ghci" "Run ghci in the context of package(s) (experimental)" ghciCmd ghciOptsParser addGhciCommand' "repl" "Run ghci in the context of package(s) (experimental) (alias for 'ghci')" ghciCmd ghciOptsParser addCommand' "runghc" "Run runghc" execCmd (execOptsParser $ Just ExecRunGhc) addCommand' "runhaskell" "Run runghc (alias for 'runghc')" execCmd (execOptsParser $ Just ExecRunGhc) addCommand' "script" "Run a Stack Script" scriptCmd scriptOptsParser unless isInterpreter (do addCommand' "eval" "Evaluate some haskell code inline. Shortcut for 'stack exec ghc -- -e CODE'" evalCmd (evalOptsParser "CODE") addCommand' "clean" "Clean the local packages" cleanCmd cleanOptsParser addCommand' "list-dependencies" "List the dependencies" (listDependenciesCmd True) listDepsOptsParser addCommand' "query" "Query general build information (experimental)" queryCmd (many $ strArgument $ metavar "SELECTOR...") addSubCommands' "ide" "IDE-specific commands" (do addCommand' "packages" "List all available local loadable packages" idePackagesCmd (pure ()) addCommand' "targets" "List all available stack targets" ideTargetsCmd (pure ())) addSubCommands' Docker.dockerCmdName "Subcommands specific to Docker use" (do addCommand' Docker.dockerPullCmdName "Pull latest version of Docker image from registry" dockerPullCmd (pure ()) addCommand' "reset" "Reset the Docker sandbox" dockerResetCmd (switch (long "keep-home" <> help "Do not delete sandbox's home directory")) addCommand' Docker.dockerCleanupCmdName "Clean up Docker images and containers" dockerCleanupCmd dockerCleanupOptsParser) addSubCommands' ConfigCmd.cfgCmdName "Subcommands specific to modifying stack.yaml files" (addCommand' ConfigCmd.cfgCmdSetName "Sets a field in the project's stack.yaml to value" cfgSetCmd configCmdSetParser) addSubCommands' Image.imgCmdName "Subcommands specific to imaging" (addCommand' Image.imgDockerCmdName "Build a Docker image for the project" imgDockerCmd ((,) <$> boolFlags True "build" "building the project before creating the container" idm <*> many (textOption (long "image" <> help "A specific container image name to build")))) addSubCommands' "hpc" "Subcommands specific to Haskell Program Coverage" (addCommand' "report" "Generate unified HPC coverage report from tix files and project targets" hpcReportCmd hpcReportOptsParser) ) where -- addCommand hiding global options addCommand' :: String -> String -> (a -> GlobalOpts -> IO ()) -> Parser a -> AddCommand addCommand' cmd title constr = addCommand cmd title globalFooter constr (globalOpts OtherCmdGlobalOpts) addSubCommands' :: String -> String -> AddCommand -> AddCommand addSubCommands' cmd title = addSubCommands cmd title globalFooter (globalOpts OtherCmdGlobalOpts) -- Additional helper that hides global options and shows build options addBuildCommand' :: String -> String -> (a -> GlobalOpts -> IO ()) -> Parser a -> AddCommand addBuildCommand' cmd title constr = addCommand cmd title globalFooter constr (globalOpts BuildCmdGlobalOpts) -- Additional helper that hides global options and shows some ghci options addGhciCommand' :: String -> String -> (a -> GlobalOpts -> IO ()) -> Parser a -> AddCommand addGhciCommand' cmd title constr = addCommand cmd title globalFooter constr (globalOpts GhciCmdGlobalOpts) globalOpts :: GlobalOptsContext -> Parser GlobalOptsMonoid globalOpts kind = extraHelpOption hide progName (Docker.dockerCmdName ++ "*") Docker.dockerHelpOptName <*> extraHelpOption hide progName (Nix.nixCmdName ++ "*") Nix.nixHelpOptName <*> globalOptsParser currentDir kind (if isInterpreter -- Silent except when errors occur - see #2879 then Just LevelError else Nothing) where hide = kind /= OuterGlobalOpts globalFooter = "Run 'stack --help' for global options that apply to all subcommands." type AddCommand = ExceptT (GlobalOpts -> IO ()) (Writer (Mod CommandFields (GlobalOpts -> IO (), GlobalOptsMonoid))) () -- | fall-through to external executables in `git` style if they exist -- (i.e. `stack something` looks for `stack-something` before -- failing with "Invalid argument `something'") secondaryCommandHandler :: [String] -> ParserFailure ParserHelp -> IO (ParserFailure ParserHelp) secondaryCommandHandler args f = -- don't even try when the argument looks like a path or flag if elem pathSeparator cmd || "-" `isPrefixOf` head args then return f else do mExternalExec <- D.findExecutable cmd case mExternalExec of Just ex -> withProcessContextNoLogging $ do -- TODO show the command in verbose mode -- hPutStrLn stderr $ unwords $ -- ["Running", "[" ++ ex, unwords (tail args) ++ "]"] _ <- exec ex (tail args) return f Nothing -> return $ fmap (vcatErrorHelp (noSuchCmd cmd)) f where -- FIXME this is broken when any options are specified before the command -- e.g. stack --verbosity silent cmd cmd = stackProgName ++ "-" ++ head args noSuchCmd name = errorHelp $ stringChunk ("Auxiliary command not found in path `" ++ name ++ "'") interpreterHandler :: Monoid t => FilePath -> [String] -> ParserFailure ParserHelp -> IO (GlobalOptsMonoid, (GlobalOpts -> IO (), t)) interpreterHandler currentDir args f = do -- args can include top-level config such as --extra-lib-dirs=... (set by -- nix-shell) - we need to find the first argument which is a file, everything -- afterwards is an argument to the script, everything before is an argument -- to Stack (stackArgs, fileArgs) <- spanM (fmap not . D.doesFileExist) args case fileArgs of (file:fileArgs') -> runInterpreterCommand file stackArgs fileArgs' [] -> parseResultHandler (errorCombine (noSuchFile firstArg)) where firstArg = head args spanM _ [] = return ([], []) spanM p xs@(x:xs') = do r <- p x if r then do (ys, zs) <- spanM p xs' return (x:ys, zs) else return ([], xs) -- if the first argument contains a path separator then it might be a file, -- or a Stack option referencing a file. In that case we only show the -- interpreter error message and exclude the command related error messages. errorCombine = if pathSeparator `elem` firstArg then overrideErrorHelp else vcatErrorHelp overrideErrorHelp h1 h2 = h2 { helpError = helpError h1 } parseResultHandler fn = handleParseResult (overFailure fn (Failure f)) noSuchFile name = errorHelp $ stringChunk ("File does not exist or is not a regular file `" ++ name ++ "'") runInterpreterCommand path stackArgs fileArgs = do progName <- getProgName iargs <- getInterpreterArgs path let parseCmdLine = commandLineHandler currentDir progName True -- Implicit file arguments are put before other arguments that -- occur after "--". See #3658 cmdArgs = stackArgs ++ case break (== "--") iargs of (beforeSep, []) -> beforeSep ++ ["--"] ++ [path] ++ fileArgs (beforeSep, optSep : afterSep) -> beforeSep ++ [optSep] ++ [path] ++ fileArgs ++ afterSep -- TODO show the command in verbose mode -- hPutStrLn stderr $ unwords $ -- ["Running", "[" ++ progName, unwords cmdArgs ++ "]"] (a,b) <- withArgs cmdArgs parseCmdLine return (a,(b,mempty)) pathCmd :: [Text] -> GlobalOpts -> IO () pathCmd keys go = withBuildConfig go (Stack.Path.path keys) setupCmd :: SetupCmdOpts -> GlobalOpts -> IO () setupCmd sco@SetupCmdOpts{..} go@GlobalOpts{..} = loadConfigWithOpts go $ \lc -> do when (isJust scoUpgradeCabal && nixEnable (configNix (lcConfig lc))) $ do throwIO UpgradeCabalUnusable withUserFileLock go (view stackRootL lc) $ \lk -> do let getCompilerVersion = loadCompilerVersion go lc runRIO (lcConfig lc) $ Docker.reexecWithOptionalContainer (lcProjectRoot lc) Nothing (runRIO (lcConfig lc) $ Nix.reexecWithOptionalShell (lcProjectRoot lc) getCompilerVersion $ do (wantedCompiler, compilerCheck, mstack) <- case scoCompilerVersion of Just v -> return (v, MatchMinor, Nothing) Nothing -> do bc <- liftIO $ lcLoadBuildConfig lc globalCompiler return ( view wantedCompilerVersionL bc , configCompilerCheck (lcConfig lc) , Just $ view stackYamlL bc ) runRIO (loadMiniConfig (lcConfig lc)) $ setup sco wantedCompiler compilerCheck mstack ) Nothing (Just $ munlockFile lk) cleanCmd :: CleanOpts -> GlobalOpts -> IO () cleanCmd opts go = -- See issues #2010 and #3468 for why "stack clean --full" is not used -- within docker. case opts of CleanFull{} -> withBuildConfigAndLockNoDocker go (const (clean opts)) CleanShallow{} -> withBuildConfigAndLock go (const (clean opts)) -- | Helper for build and install commands buildCmd :: BuildOptsCLI -> GlobalOpts -> IO () buildCmd opts go = do when (any (("-prof" `elem`) . either (const []) id . parseArgs Escaping) (boptsCLIGhcOptions opts)) $ do hPutStrLn stderr "Error: When building with stack, you should not use the -prof GHC option" hPutStrLn stderr "Instead, please use --library-profiling and --executable-profiling" hPutStrLn stderr "See: https://github.com/commercialhaskell/stack/issues/1015" System.Exit.exitFailure case boptsCLIFileWatch opts of FileWatchPoll -> fileWatchPoll stderr inner FileWatch -> fileWatch stderr inner NoFileWatch -> inner $ const $ return () where inner setLocalFiles = withBuildConfigAndLock go' $ \lk -> Stack.Build.build setLocalFiles lk opts -- Read the build command from the CLI and enable it to run go' = case boptsCLICommand opts of Test -> set (globalOptsBuildOptsMonoidL.buildOptsMonoidTestsL) (Just True) go Haddock -> set (globalOptsBuildOptsMonoidL.buildOptsMonoidHaddockL) (Just True) go Bench -> set (globalOptsBuildOptsMonoidL.buildOptsMonoidBenchmarksL) (Just True) go Install -> set (globalOptsBuildOptsMonoidL.buildOptsMonoidInstallExesL) (Just True) go Build -> go -- Default case is just Build uninstallCmd :: [String] -> GlobalOpts -> IO () uninstallCmd _ go = withConfigAndLock go $ prettyErrorL [ flow "stack does not manage installations in global locations." , flow "The only global mutation stack performs is executable copying." , flow "For the default executable destination, please run" , styleShell "stack path --local-bin" ] -- | Unpack packages to the filesystem unpackCmd :: ([String], Maybe Text) -> GlobalOpts -> IO () unpackCmd (names, Nothing) go = unpackCmd (names, Just ".") go unpackCmd (names, Just dstPath) go = withConfigAndLock go $ do mSnapshotDef <- mapM (makeConcreteResolver Nothing >=> loadResolver) (globalResolver go) Stack.Fetch.unpackPackages mSnapshotDef (T.unpack dstPath) names -- | Update the package index updateCmd :: () -> GlobalOpts -> IO () updateCmd () go = withConfigAndLock go Stack.PackageIndex.updateAllIndices upgradeCmd :: UpgradeOpts -> GlobalOpts -> IO () upgradeCmd upgradeOpts' go = withGlobalConfigAndLock go $ upgrade (globalConfigMonoid go) (globalResolver go) #ifdef USE_GIT_INFO (either (const Nothing) (Just . giHash) $$tGitInfoCwdTry) #else Nothing #endif upgradeOpts' -- | Upload to Hackage uploadCmd :: SDistOpts -> GlobalOpts -> IO () uploadCmd (SDistOpts [] _ _ _ _ _ _) go = withConfigAndLock go . prettyErrorL $ [ flow "To upload the current package, please run" , styleShell "stack upload ." , flow "(with the period at the end)" ] uploadCmd sdistOpts go = do let partitionM _ [] = return ([], []) partitionM f (x:xs) = do r <- f x (as, bs) <- partitionM f xs return $ if r then (x:as, bs) else (as, x:bs) (files, nonFiles) <- partitionM D.doesFileExist (sdoptsDirsToWorkWith sdistOpts) (dirs, invalid) <- partitionM D.doesDirectoryExist nonFiles withBuildConfigAndLock go $ \_ -> do unless (null invalid) $ do let invalidList = bulletedList $ map (styleFile . fromString) invalid prettyErrorL [ styleShell "stack upload" , flow "expects a list of sdist tarballs or package directories." , flow "Can't find:" , line <> invalidList ] liftIO System.Exit.exitFailure when (null files && null dirs) $ do prettyErrorL [ styleShell "stack upload" , flow "expects a list of sdist tarballs or package directories, but none were specified." ] liftIO System.Exit.exitFailure config <- view configL let hackageUrl = T.unpack $ configHackageBaseUrl config getCreds <- liftIO (runOnce (Upload.loadCreds config)) mapM_ (resolveFile' >=> checkSDistTarball sdistOpts) files forM_ files (\file -> do tarFile <- resolveFile' file liftIO $ do creds <- getCreds Upload.upload hackageUrl creds (toFilePath tarFile) when (sdoptsSign sdistOpts) (void $ Sig.sign (sdoptsSignServerUrl sdistOpts) tarFile)) unless (null dirs) $ forM_ dirs $ \dir -> do pkgDir <- resolveDir' dir (tarName, tarBytes, mcabalRevision) <- getSDistTarball (sdoptsPvpBounds sdistOpts) pkgDir checkSDistTarball' sdistOpts tarName tarBytes liftIO $ do creds <- getCreds Upload.uploadBytes hackageUrl creds tarName tarBytes forM_ mcabalRevision $ uncurry $ Upload.uploadRevision hackageUrl creds tarPath <- parseRelFile tarName when (sdoptsSign sdistOpts) (void $ Sig.signTarBytes (sdoptsSignServerUrl sdistOpts) tarPath tarBytes) sdistCmd :: SDistOpts -> GlobalOpts -> IO () sdistCmd sdistOpts go = withBuildConfig go $ do -- No locking needed. -- If no directories are specified, build all sdist tarballs. dirs' <- if null (sdoptsDirsToWorkWith sdistOpts) then do dirs <- liftM (map lpvRoot . Map.elems . lpProject) getLocalPackages when (null dirs) $ do stackYaml <- view stackYamlL prettyErrorL [ styleShell "stack sdist" , flow "expects a list of targets, and otherwise defaults to all of the project's packages." , flow "However, the configuration at" , display stackYaml , flow "contains no packages, so no sdist tarballs will be generated." ] liftIO System.Exit.exitFailure return dirs else mapM resolveDir' (sdoptsDirsToWorkWith sdistOpts) forM_ dirs' $ \dir -> do (tarName, tarBytes, _mcabalRevision) <- getSDistTarball (sdoptsPvpBounds sdistOpts) dir distDir <- distDirFromDir dir tarPath <- (distDir ) <$> parseRelFile tarName ensureDir (parent tarPath) liftIO $ L.writeFile (toFilePath tarPath) tarBytes prettyInfoL [flow "Wrote sdist tarball to", display tarPath] checkSDistTarball sdistOpts tarPath forM_ (sdoptsTarPath sdistOpts) $ copyTarToTarPath tarPath tarName when (sdoptsSign sdistOpts) (void $ Sig.sign (sdoptsSignServerUrl sdistOpts) tarPath) where copyTarToTarPath tarPath tarName targetDir = liftIO $ do let targetTarPath = targetDir FP. tarName D.createDirectoryIfMissing True $ FP.takeDirectory targetTarPath D.copyFile (toFilePath tarPath) targetTarPath -- | Execute a command. execCmd :: ExecOpts -> GlobalOpts -> IO () execCmd ExecOpts {..} go@GlobalOpts{..} = case eoExtra of ExecOptsPlain -> do loadConfigWithOpts go $ \lc -> withUserFileLock go (view stackRootL lc) $ \lk -> do let getCompilerVersion = loadCompilerVersion go lc runRIO (lcConfig lc) $ Docker.reexecWithOptionalContainer (lcProjectRoot lc) -- Unlock before transferring control away, whether using docker or not: (Just $ munlockFile lk) (withBuildConfigAndLock go $ \buildLock -> do config <- view configL menv <- liftIO $ configProcessContextSettings config plainEnvSettings withProcessContext menv $ do (cmd, args) <- case (eoCmd, eoArgs) of (ExecCmd cmd, args) -> return (cmd, args) (ExecRun, args) -> getRunCmd args (ExecGhc, args) -> return ("ghc", args) (ExecRunGhc, args) -> return ("runghc", args) munlockFile buildLock Nix.reexecWithOptionalShell (lcProjectRoot lc) getCompilerVersion (runRIO (lcConfig lc) $ exec cmd args)) Nothing Nothing -- Unlocked already above. ExecOptsEmbellished {..} -> withBuildConfigAndLock go $ \lk -> do let targets = concatMap words eoPackages unless (null targets) $ Stack.Build.build (const $ return ()) lk defaultBuildOptsCLI { boptsCLITargets = map T.pack targets } config <- view configL menv <- liftIO $ configProcessContextSettings config eoEnvSettings withProcessContext menv $ do -- Add RTS options to arguments let argsWithRts args = if null eoRtsOptions then args :: [String] else args ++ ["+RTS"] ++ eoRtsOptions ++ ["-RTS"] (cmd, args) <- case (eoCmd, argsWithRts eoArgs) of (ExecCmd cmd, args) -> return (cmd, args) (ExecRun, args) -> getRunCmd args (ExecGhc, args) -> getGhcCmd "" eoPackages args -- NOTE: This doesn't work for GHCJS, because it doesn't have -- a runghcjs binary. (ExecRunGhc, args) -> getGhcCmd "run" eoPackages args munlockFile lk -- Unlock before transferring control away. runWithPath eoCwd $ exec cmd args where -- return the package-id of the first package in GHC_PACKAGE_PATH getPkgId wc name = do mId <- findGhcPkgField wc [] name "id" case mId of Just i -> return (head $ words (T.unpack i)) -- should never happen as we have already installed the packages _ -> liftIO $ do hPutStrLn stderr ("Could not find package id of package " ++ name) System.Exit.exitFailure getPkgOpts wc pkgs = map ("-package-id=" ++) <$> mapM (getPkgId wc) pkgs getRunCmd args = do pkgComponents <- liftM (map lpvComponents . Map.elems . lpProject) getLocalPackages let executables = filter isCExe $ concatMap Set.toList pkgComponents let (exe, args') = case args of [] -> (firstExe, args) x:xs -> case find (\y -> y == (CExe $ T.pack x)) executables of Nothing -> (firstExe, args) argExe -> (argExe, xs) where firstExe = listToMaybe executables case exe of Just (CExe exe') -> do Stack.Build.build (const (return ())) Nothing defaultBuildOptsCLI{boptsCLITargets = [T.cons ':' exe']} return (T.unpack exe', args') _ -> do logError "No executables found." liftIO System.Exit.exitFailure getGhcCmd prefix pkgs args = do wc <- view $ actualCompilerVersionL.whichCompilerL pkgopts <- getPkgOpts wc pkgs return (prefix ++ compilerExeName wc, pkgopts ++ args) runWithPath :: Maybe FilePath -> RIO EnvConfig () -> RIO EnvConfig () runWithPath path callback = case path of Nothing -> callback Just p | not (isValid p) -> throwIO $ InvalidPathForExec p Just p -> withUnliftIO $ \ul -> D.withCurrentDirectory p $ unliftIO ul callback -- | Evaluate some haskell code inline. evalCmd :: EvalOpts -> GlobalOpts -> IO () evalCmd EvalOpts {..} go@GlobalOpts {..} = execCmd execOpts go where execOpts = ExecOpts { eoCmd = ExecGhc , eoArgs = ["-e", evalArg] , eoExtra = evalExtra } -- | Run GHCi in the context of a project. ghciCmd :: GhciOpts -> GlobalOpts -> IO () ghciCmd ghciOpts go@GlobalOpts{..} = withBuildConfigAndLock go $ \lk -> do munlockFile lk -- Don't hold the lock while in the GHCI. bopts <- view buildOptsL -- override env so running of tests and benchmarks is disabled let boptsLocal = bopts { boptsTestOpts = (boptsTestOpts bopts) { toDisableRun = True } , boptsBenchmarkOpts = (boptsBenchmarkOpts bopts) { beoDisableRun = True } } local (set buildOptsL boptsLocal) (ghci ghciOpts) -- | List packages in the project. idePackagesCmd :: () -> GlobalOpts -> IO () idePackagesCmd () go = withBuildConfig go IDE.listPackages -- | List targets in the project. ideTargetsCmd :: () -> GlobalOpts -> IO () ideTargetsCmd () go = withBuildConfig go IDE.listTargets -- | Pull the current Docker image. dockerPullCmd :: () -> GlobalOpts -> IO () dockerPullCmd _ go@GlobalOpts{..} = loadConfigWithOpts go $ \lc -> -- TODO: can we eliminate this lock if it doesn't touch ~/.stack/? withUserFileLock go (view stackRootL lc) $ \_ -> runRIO (lcConfig lc) $ Docker.preventInContainer Docker.pull -- | Reset the Docker sandbox. dockerResetCmd :: Bool -> GlobalOpts -> IO () dockerResetCmd keepHome go@GlobalOpts{..} = loadConfigWithOpts go $ \lc -> -- TODO: can we eliminate this lock if it doesn't touch ~/.stack/? withUserFileLock go (view stackRootL lc) $ \_ -> runRIO (lcConfig lc) $ Docker.preventInContainer $ Docker.reset (lcProjectRoot lc) keepHome -- | Cleanup Docker images and containers. dockerCleanupCmd :: Docker.CleanupOpts -> GlobalOpts -> IO () dockerCleanupCmd cleanupOpts go@GlobalOpts{..} = loadConfigWithOpts go $ \lc -> -- TODO: can we eliminate this lock if it doesn't touch ~/.stack/? withUserFileLock go (view stackRootL lc) $ \_ -> runRIO (lcConfig lc) $ Docker.preventInContainer $ Docker.cleanup cleanupOpts cfgSetCmd :: ConfigCmd.ConfigCmdSet -> GlobalOpts -> IO () cfgSetCmd co go@GlobalOpts{..} = withMiniConfigAndLock go (cfgCmdSet go co) imgDockerCmd :: (Bool, [Text]) -> GlobalOpts -> IO () imgDockerCmd (rebuild,images) go@GlobalOpts{..} = loadConfigWithOpts go $ \lc -> do let mProjectRoot = lcProjectRoot lc withBuildConfigExt False go Nothing (\lk -> do when rebuild $ Stack.Build.build (const (return ())) lk defaultBuildOptsCLI Image.stageContainerImageArtifacts mProjectRoot images) (Just $ Image.createContainerImageFromStage mProjectRoot images) -- | Project initialization initCmd :: InitOpts -> GlobalOpts -> IO () initCmd initOpts go = do pwd <- getCurrentDir withMiniConfigAndLock go (initProject IsInitCmd pwd initOpts (globalResolver go)) -- | Create a project directory structure and initialize the stack config. newCmd :: (NewOpts,InitOpts) -> GlobalOpts -> IO () newCmd (newOpts,initOpts) go@GlobalOpts{..} = withMiniConfigAndLock go $ do dir <- new newOpts (forceOverwrite initOpts) exists <- doesFileExist $ dir stackDotYaml when (forceOverwrite initOpts || not exists) $ initProject IsNewCmd dir initOpts globalResolver -- | List the available templates. templatesCmd :: () -> GlobalOpts -> IO () templatesCmd _ go@GlobalOpts{..} = withConfigAndLock go templatesHelp -- | Fix up extra-deps for a project solverCmd :: Bool -- ^ modify stack.yaml automatically? -> GlobalOpts -> IO () solverCmd fixStackYaml go = withBuildConfigAndLock go (\_ -> solveExtraDeps fixStackYaml) -- | Visualize dependencies dotCmd :: DotOpts -> GlobalOpts -> IO () dotCmd dotOpts go = withBuildConfigDot dotOpts go $ dot dotOpts -- | Query build information queryCmd :: [String] -> GlobalOpts -> IO () queryCmd selectors go = withBuildConfig go $ queryBuildInfo $ map T.pack selectors -- | Generate a combined HPC report hpcReportCmd :: HpcReportOpts -> GlobalOpts -> IO () hpcReportCmd hropts go = withBuildConfig go $ generateHpcReportForTargets hropts data MainException = InvalidReExecVersion String String | UpgradeCabalUnusable | InvalidPathForExec FilePath deriving (Typeable) instance Exception MainException instance Show MainException where show (InvalidReExecVersion expected actual) = concat [ "When re-executing '" , stackProgName , "' in a container, the incorrect version was found\nExpected: " , expected , "; found: " , actual] show UpgradeCabalUnusable = "--upgrade-cabal cannot be used when nix is activated" show (InvalidPathForExec path) = concat [ "Got an invalid --cwd argument for stack exec (" , path , ")"] stack-1.9.3.1/src/test/Test.hs0000644000000000000000000000011613455617610014205 0ustar0000000000000000import Test.Hspec (hspec) import Spec (spec) main :: IO () main = hspec spec stack-1.9.3.1/src/test/Network/HTTP/Download/VerifiedSpec.hs0000644000000000000000000001244013455617610021620 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude #-} module Network.HTTP.Download.VerifiedSpec where import Control.Retry (limitRetries) import Crypto.Hash import Network.HTTP.StackClient import Network.HTTP.Download.Verified import Path import Path.IO hiding (withSystemTempDir) import Stack.Prelude import Stack.Types.Runner import System.IO (writeFile, readFile) import Test.Hspec -- TODO: share across test files withTempDir' :: (Path Abs Dir -> IO a) -> IO a withTempDir' = withSystemTempDir "NHD_VerifiedSpec" -- | An example path to download the exampleReq. getExamplePath :: Path Abs Dir -> IO (Path Abs File) getExamplePath dir = do file <- parseRelFile "cabal-install-1.22.4.0.tar.gz" return (dir file) -- | An example DownloadRequest that uses a SHA1 exampleReq :: DownloadRequest exampleReq = fromMaybe (error "exampleReq") $ do let req = parseRequest_ "http://download.fpcomplete.com/stackage-cli/linux64/cabal-install-1.22.4.0.tar.gz" return DownloadRequest { drRequest = req , drHashChecks = [exampleHashCheck] , drLengthCheck = Just exampleLengthCheck , drRetryPolicy = limitRetries 1 } exampleHashCheck :: HashCheck exampleHashCheck = HashCheck { hashCheckAlgorithm = SHA1 , hashCheckHexDigest = CheckHexDigestString "b98eea96d321cdeed83a201c192dac116e786ec2" } exampleLengthCheck :: LengthCheck exampleLengthCheck = 302513 -- | The wrong ContentLength for exampleReq exampleWrongContentLength :: Int exampleWrongContentLength = 302512 -- | The wrong SHA1 digest for exampleReq exampleWrongDigest :: CheckHexDigest exampleWrongDigest = CheckHexDigestString "b98eea96d321cdeed83a201c192dac116e786ec3" exampleWrongContent :: String exampleWrongContent = "example wrong content" isWrongContentLength :: VerifiedDownloadException -> Bool isWrongContentLength WrongContentLength{} = True isWrongContentLength _ = False isWrongDigest :: VerifiedDownloadException -> Bool isWrongDigest WrongDigest{} = True isWrongDigest _ = False spec :: Spec spec = do let exampleProgressHook _ = return () describe "verifiedDownload" $ do let run func = withRunner LevelError True True ColorNever Nothing False $ \runner -> runRIO runner func -- Preconditions: -- * the exampleReq server is running -- * the test runner has working internet access to it it "downloads the file correctly" $ withTempDir' $ \dir -> do examplePath <- getExamplePath dir doesFileExist examplePath `shouldReturn` False let go = run $ verifiedDownload exampleReq examplePath exampleProgressHook go `shouldReturn` True doesFileExist examplePath `shouldReturn` True it "is idempotent, and doesn't redownload unnecessarily" $ withTempDir' $ \dir -> do examplePath <- getExamplePath dir doesFileExist examplePath `shouldReturn` False let go = run $ verifiedDownload exampleReq examplePath exampleProgressHook go `shouldReturn` True doesFileExist examplePath `shouldReturn` True go `shouldReturn` False doesFileExist examplePath `shouldReturn` True -- https://github.com/commercialhaskell/stack/issues/372 it "does redownload when the destination file is wrong" $ withTempDir' $ \dir -> do examplePath <- getExamplePath dir let exampleFilePath = toFilePath examplePath writeFile exampleFilePath exampleWrongContent doesFileExist examplePath `shouldReturn` True readFile exampleFilePath `shouldReturn` exampleWrongContent let go = run $ verifiedDownload exampleReq examplePath exampleProgressHook go `shouldReturn` True doesFileExist examplePath `shouldReturn` True readFile exampleFilePath `shouldNotReturn` exampleWrongContent it "rejects incorrect content length" $ withTempDir' $ \dir -> do examplePath <- getExamplePath dir let wrongContentLengthReq = exampleReq { drLengthCheck = Just exampleWrongContentLength } let go = run $ verifiedDownload wrongContentLengthReq examplePath exampleProgressHook go `shouldThrow` isWrongContentLength doesFileExist examplePath `shouldReturn` False it "rejects incorrect digest" $ withTempDir' $ \dir -> do examplePath <- getExamplePath dir let wrongHashCheck = exampleHashCheck { hashCheckHexDigest = exampleWrongDigest } let wrongDigestReq = exampleReq { drHashChecks = [wrongHashCheck] } let go = run $ verifiedDownload wrongDigestReq examplePath exampleProgressHook go `shouldThrow` isWrongDigest doesFileExist examplePath `shouldReturn` False -- https://github.com/commercialhaskell/stack/issues/240 it "can download hackage tarballs" $ withTempDir' $ \dir -> do dest <- (dir ) <$> parseRelFile "acme-missiles-0.3.tar.gz" let req = parseRequest_ "http://hackage.haskell.org/package/acme-missiles-0.3/acme-missiles-0.3.tar.gz" let dReq = DownloadRequest { drRequest = req , drHashChecks = [] , drLengthCheck = Nothing , drRetryPolicy = limitRetries 1 } let go = run $ verifiedDownload dReq dest exampleProgressHook doesFileExist dest `shouldReturn` False go `shouldReturn` True doesFileExist dest `shouldReturn` True stack-1.9.3.1/src/test/Spec.hs0000644000000000000000000000015013455617610014156 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude #-} {-# OPTIONS_GHC -F -pgmF hspec-discover -optF --module-name=Spec #-} stack-1.9.3.1/src/test/Stack/ArgsSpec.hs0000644000000000000000000001376513455617610016060 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude #-} -- | Args parser test suite. module Stack.ArgsSpec where import Control.Monad import Data.Attoparsec.Args (EscapingMode(..), parseArgsFromString) import Data.Attoparsec.Interpreter (interpreterArgsParser) import qualified Data.Attoparsec.Text as P import Data.Text (pack) import Stack.Constants (stackProgName) import Stack.Prelude import Test.Hspec import Prelude (head) -- | Test spec. spec :: Spec spec = do argsSpec interpreterArgsSpec argsSpec :: Spec argsSpec = forM_ argsInputOutput (\(input,output) -> it input (parseArgsFromString Escaping input == output)) -- | Fairly comprehensive checks. argsInputOutput :: [(String, Either String [String])] argsInputOutput = [ ("x", Right ["x"]) , ("x y z", Right ["x", "y", "z"]) , ("aaa bbb ccc", Right ["aaa", "bbb", "ccc"]) , (" aaa bbb ccc ", Right ["aaa", "bbb", "ccc"]) , ("aaa\"", Left "unterminated string: endOfInput") , ("\"", Left "unterminated string: endOfInput") , ("\"\"", Right [""]) , ("\"aaa", Left "unterminated string: endOfInput") , ("\"aaa\" bbb ccc \"ddd\"", Right ["aaa", "bbb", "ccc", "ddd"]) , ("\"aa\\\"a\" bbb ccc \"ddd\"", Right ["aa\"a", "bbb", "ccc", "ddd"]) , ("\"aa\\\"a\" bb\\b ccc \"ddd\"", Right ["aa\"a", "bb\\b", "ccc", "ddd"]) , ("\"\" \"\" c", Right ["","","c"])] interpreterArgsSpec :: Spec interpreterArgsSpec = describe "Script interpreter parser" $ do describe "Success cases" $ do describe "Line comments" $ do checkLines "" checkLines " --x" checkLines " --x --y" describe "Literate line comments" $ do checkLiterateLines "" checkLiterateLines " --x" checkLiterateLines " --x --y" describe "Block comments" $ do checkBlocks "" checkBlocks "\n" checkBlocks " --x" checkBlocks "\n--x" checkBlocks " --x --y" checkBlocks "\n--x\n--y" checkBlocks "\n\t--x\n\t--y" describe "Literate block comments" $ do checkLiterateBlocks "" "" checkLiterateBlocks "\n>" "" checkLiterateBlocks " --x" " --x" checkLiterateBlocks "\n>--x" "--x" checkLiterateBlocks " --x --y " "--x --y" checkLiterateBlocks "\n>--x\n>--y" "--x --y" checkLiterateBlocks "\n>\t--x\n>\t--y" "--x --y" describe "Failure cases" $ do checkFailures describe "Bare directives in literate files" $ do forM_ (interpreterGenValid lineComment []) $ testAndCheck (acceptFailure True) [] forM_ (interpreterGenValid blockComment []) $ testAndCheck (acceptFailure True) [] where parse isLiterate s = P.parseOnly (interpreterArgsParser isLiterate stackProgName) (pack s) acceptSuccess :: Bool -> String -> String -> Bool acceptSuccess isLiterate args s = case parse isLiterate s of Right x | words x == words args -> True _ -> False acceptFailure isLiterate _ s = case parse isLiterate s of Left _ -> True Right _ -> False showInput i = "BEGIN =>" ++ i ++ "<= END" testAndCheck checker out inp = it (showInput inp) $ checker out inp checkLines args = forM_ (interpreterGenValid lineComment args) (testAndCheck (acceptSuccess False) args) checkLiterateLines args = forM_ (interpreterGenValid literateLineComment args) (testAndCheck (acceptSuccess True) args) checkBlocks args = forM_ (interpreterGenValid blockComment args) (testAndCheck (acceptSuccess False) args) checkLiterateBlocks inp args = forM_ (interpreterGenValid literateBlockComment inp) (testAndCheck (acceptSuccess True) args) checkFailures = forM_ interpreterGenInvalid (testAndCheck (acceptFailure False) "unused") -- Generate a set of acceptable inputs for given format and args interpreterGenValid fmt args = shebang <++> newLine <++> fmt args interpreterGenInvalid :: [String] -- Generate a set of Invalid inputs interpreterGenInvalid = ["-stack\n"] -- random input -- just the shebang <|> shebang <++> ["\n"] -- invalid shebang <|> blockSpace <++> [head (interpreterGenValid lineComment args)] -- something between shebang and stack comment <|> shebang <++> newLine <++> blockSpace <++> ([head (lineComment args)] <|> [head (blockComment args)]) -- unterminated block comment -- just chop the closing chars from a valid block comment <|> shebang <++> ["\n"] <++> let c = head (blockComment args) l = length c - 2 in [assert (drop l c == "-}") (take l c)] -- nested block comment <|> shebang <++> ["\n"] <++> [head (blockComment "--x {- nested -} --y")] where args = " --x --y" (<++>) = liftA2 (++) -- Generative grammar for the interpreter comments shebang = ["#!/usr/bin/env stack"] newLine = ["\n"] <|> ["\r\n"] -- A comment may be the last line or followed by something else postComment = [""] <|> newLine -- A command starts with zero or more whitespace followed by "stack" makeComment maker space args = let makePrefix s = (s <|> [""]) <++> [stackProgName] in (maker <$> (makePrefix space <++> [args])) <++> postComment lineSpace = [" "] <|> ["\t"] lineComment = makeComment makeLine lineSpace where makeLine s = "--" ++ s literateLineComment = makeComment ("> --" ++) lineSpace blockSpace = lineSpace <|> newLine blockComment = makeComment makeBlock blockSpace where makeBlock s = "{-" ++ s ++ "-}" literateBlockComment = makeComment (\s -> "> {-" ++ s ++ "-}") (lineSpace <|> map (++ ">") newLine) stack-1.9.3.1/src/test/Stack/Build/ExecuteSpec.hs0000644000000000000000000000027513312026775017613 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude #-} module Stack.Build.ExecuteSpec (main, spec) where import Stack.Prelude import Test.Hspec main :: IO () main = hspec spec spec :: Spec spec = return () stack-1.9.3.1/src/test/Stack/Build/TargetSpec.hs0000644000000000000000000000232113455617610017433 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude #-} {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TemplateHaskell #-} module Stack.Build.TargetSpec (main, spec) where import qualified Data.Text as T import Stack.Build.Target import Stack.Prelude import Stack.Types.NamedComponent import Stack.Types.PackageIdentifier import Stack.Types.PackageName import Stack.Types.Version import Test.Hspec main :: IO () main = hspec spec spec :: Spec spec = do describe "parseRawTarget" $ do let test s e = it s $ parseRawTarget (T.pack s) `shouldBe` e test "foobar" $ Just $ RTPackage $(mkPackageName "foobar") test "foobar-1.2.3" $ Just $ RTPackageIdentifier $ PackageIdentifier $(mkPackageName "foobar") $(mkVersion "1.2.3") test "./foobar" Nothing test "foobar/" Nothing test "/foobar" Nothing test ":some-exe" $ Just $ RTComponent "some-exe" test "foobar:some-exe" $ Just $ RTPackageComponent $(mkPackageName "foobar") $ UnresolvedComponent "some-exe" test "foobar:exe:some-exe" $ Just $ RTPackageComponent $(mkPackageName "foobar") $ ResolvedComponent $ CExe "some-exe" stack-1.9.3.1/src/test/Stack/ConfigSpec.hs0000644000000000000000000001442513455617610016363 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude #-} {-# LANGUAGE FlexibleContexts #-} {-# LANGUAGE RecordWildCards #-} {-# LANGUAGE TemplateHaskell #-} module Stack.ConfigSpec where import Control.Arrow import Data.Aeson.Extended import Data.Yaml import Path import Path.IO hiding (withSystemTempDir) import Stack.Config import Stack.Prelude import Stack.Types.Config import Stack.Types.Runner import System.Directory import System.Environment import System.IO (writeFile) import Test.Hspec sampleConfig :: String sampleConfig = "resolver: lts-2.10\n" ++ "packages: ['.']\n" buildOptsConfig :: String buildOptsConfig = "resolver: lts-2.10\n" ++ "packages: ['.']\n" ++ "build:\n" ++ " library-profiling: true\n" ++ " executable-profiling: true\n" ++ " haddock: true\n" ++ " haddock-deps: true\n" ++ " copy-bins: true\n" ++ " prefetch: true\n" ++ " force-dirty: true\n" ++ " keep-going: true\n" ++ " keep-tmp-files: true\n" ++ " test: true\n" ++ " test-arguments:\n" ++ " rerun-tests: true\n" ++ " additional-args: ['-fprof']\n" ++ " coverage: true\n" ++ " no-run-tests: true\n" ++ " bench: true\n" ++ " benchmark-opts:\n" ++ " benchmark-arguments: -O2\n" ++ " no-run-benchmarks: true\n" ++ " reconfigure: true\n" ++ " cabal-verbose: true\n" hpackConfig :: String hpackConfig = "resolver: lts-2.10\n" ++ "with-hpack: /usr/local/bin/hpack\n" ++ "packages: ['.']\n" stackDotYaml :: Path Rel File stackDotYaml = $(mkRelFile "stack.yaml") setup :: IO () setup = unsetEnv "STACK_YAML" noException :: Selector SomeException noException = const False spec :: Spec spec = beforeAll setup $ do let logLevel = LevelDebug -- TODO(danburton): not use inTempDir let inTempDir action = do currentDirectory <- getCurrentDirectory withSystemTempDirectory "Stack_ConfigSpec" $ \tempDir -> do let enterDir = setCurrentDirectory tempDir let exitDir = setCurrentDirectory currentDirectory bracket_ enterDir exitDir action -- TODO(danburton): a safer version of this? let withEnvVar name newValue action = do originalValue <- fromMaybe "" <$> lookupEnv name let setVar = setEnv name newValue let resetVar = setEnv name originalValue bracket_ setVar resetVar action describe "loadConfig" $ do let loadConfig' inner = withRunner logLevel True False ColorAuto Nothing False $ \runner -> do lc <- runRIO runner $ loadConfig mempty Nothing SYLDefault inner lc -- TODO(danburton): make sure parent dirs also don't have config file it "works even if no config file exists" $ example $ loadConfig' $ const $ return () it "works with a blank config file" $ inTempDir $ do writeFile (toFilePath stackDotYaml) "" -- TODO(danburton): more specific test for exception loadConfig' (const (return ())) `shouldThrow` anyException it "parses config option with-hpack" $ inTempDir $ do writeFile (toFilePath stackDotYaml) hpackConfig loadConfig' $ \lc -> do let Config{..} = lcConfig lc configOverrideHpack `shouldBe` HpackCommand "/usr/local/bin/hpack" it "parses config bundled hpack" $ inTempDir $ do writeFile (toFilePath stackDotYaml) sampleConfig loadConfig' $ \lc -> do let Config{..} = lcConfig lc configOverrideHpack `shouldBe` HpackBundled it "parses build config options" $ inTempDir $ do writeFile (toFilePath stackDotYaml) buildOptsConfig loadConfig' $ \lc -> do let BuildOpts{..} = configBuild $ lcConfig lc boptsLibProfile `shouldBe` True boptsExeProfile `shouldBe` True boptsHaddock `shouldBe` True boptsHaddockDeps `shouldBe` Just True boptsInstallExes `shouldBe` True boptsPreFetch `shouldBe` True boptsKeepGoing `shouldBe` Just True boptsKeepTmpFiles `shouldBe` Just True boptsForceDirty `shouldBe` True boptsTests `shouldBe` True boptsTestOpts `shouldBe` TestOpts {toRerunTests = True ,toAdditionalArgs = ["-fprof"] ,toCoverage = True ,toDisableRun = True} boptsBenchmarks `shouldBe` True boptsBenchmarkOpts `shouldBe` BenchmarkOpts {beoAdditionalArgs = Just "-O2" ,beoDisableRun = True} boptsReconfigure `shouldBe` True boptsCabalVerbose `shouldBe` True it "finds the config file in a parent directory" $ inTempDir $ do writeFile (toFilePath stackDotYaml) sampleConfig parentDir <- getCurrentDirectory >>= parseAbsDir let childDir = "child" createDirectory childDir setCurrentDirectory childDir loadConfig' $ \LoadConfig{..} -> do bc <- liftIO (lcLoadBuildConfig Nothing) view projectRootL bc `shouldBe` parentDir it "respects the STACK_YAML env variable" $ inTempDir $ do withSystemTempDir "config-is-here" $ \dir -> do let stackYamlFp = toFilePath (dir stackDotYaml) writeFile stackYamlFp sampleConfig withEnvVar "STACK_YAML" stackYamlFp $ loadConfig' $ \LoadConfig{..} -> do BuildConfig{..} <- lcLoadBuildConfig Nothing bcStackYaml `shouldBe` dir stackDotYaml parent bcStackYaml `shouldBe` dir it "STACK_YAML can be relative" $ inTempDir $ do parentDir <- getCurrentDirectory >>= parseAbsDir let childRel = $(mkRelDir "child") yamlRel = childRel $(mkRelFile "some-other-name.config") yamlAbs = parentDir yamlRel createDirectoryIfMissing True $ toFilePath $ parent yamlAbs writeFile (toFilePath yamlAbs) "resolver: ghc-7.8" withEnvVar "STACK_YAML" (toFilePath yamlRel) $ loadConfig' $ \LoadConfig{..} -> do BuildConfig{..} <- lcLoadBuildConfig Nothing bcStackYaml `shouldBe` yamlAbs describe "defaultConfigYaml" $ it "is parseable" $ \_ -> do curDir <- getCurrentDir let parsed :: Either String (Either String (WithJSONWarnings ConfigMonoid)) parsed = parseEither (parseConfigMonoid curDir) <$> left show (decodeEither' defaultConfigYaml) case parsed of Right (Right _) -> return () :: IO () _ -> fail "Failed to parse default config yaml" stack-1.9.3.1/src/test/Stack/DotSpec.hs0000644000000000000000000001245213455617610015702 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude #-} {-# LANGUAGE CPP #-} {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TupleSections #-} -- | Test suite for Stack.Dot module Stack.DotSpec where import Data.Functor.Identity import Data.List ((\\)) import qualified Data.Map as Map import qualified Data.Set as Set import Distribution.License (License (BSD3)) import Stack.Prelude import Stack.Types.PackageName import Stack.Types.Version import Test.Hspec import Test.Hspec.QuickCheck (prop) import Test.QuickCheck (forAll,choose,Gen) import Stack.Dot dummyPayload :: DotPayload dummyPayload = DotPayload (parseVersionFromString "0.0.0.0") (Just (Right BSD3)) spec :: Spec spec = do let graph = Map.mapKeys pkgName . fmap (\p -> (Set.map pkgName p, dummyPayload)) . Map.fromList $ [("one",Set.fromList ["base","free"]) ,("two",Set.fromList ["base","free","mtl","transformers","one"]) ] describe "Stack.Dot" $ do it "does nothing if depth is 0" $ resolveDependencies (Just 0) graph stubLoader `shouldBe` return graph it "with depth 1, more dependencies are resolved" $ do let graph' = Map.insert (pkgName "cycle") (Set.singleton (pkgName "cycle"), dummyPayload) graph resultGraph = runIdentity (resolveDependencies (Just 0) graph stubLoader) resultGraph' = runIdentity (resolveDependencies (Just 1) graph' stubLoader) Map.size resultGraph < Map.size resultGraph' `shouldBe` True it "cycles are ignored" $ do let graph' = Map.insert (pkgName "cycle") (Set.singleton (pkgName "cycle"), dummyPayload) graph resultGraph = resolveDependencies Nothing graph stubLoader resultGraph' = resolveDependencies Nothing graph' stubLoader fmap Map.size resultGraph' `shouldBe` fmap ((+1) . Map.size) resultGraph let graphElem e = Set.member e . Set.unions . Map.elems prop "requested packages are pruned" $ do let resolvedGraph = runIdentity (resolveDependencies Nothing graph stubLoader) allPackages g = Set.map show (Map.keysSet g `Set.union` fold (fmap fst g)) forAll (sublistOf (Set.toList (allPackages resolvedGraph))) $ \toPrune -> let pruned = pruneGraph [pkgName "one", pkgName "two"] toPrune resolvedGraph in Set.null (allPackages pruned `Set.intersection` Set.fromList toPrune) prop "pruning removes orhpans" $ do let resolvedGraph = runIdentity (resolveDependencies Nothing graph stubLoader) allPackages g = Set.map show (Map.keysSet g `Set.union` fold (fmap fst g)) orphans g = Map.filterWithKey (\k _ -> not (graphElem k g)) g forAll (sublistOf (Set.toList (allPackages resolvedGraph))) $ \toPrune -> let pruned = pruneGraph [pkgName "one", pkgName "two"] toPrune resolvedGraph in null (Map.keys (orphans (fmap fst pruned)) \\ [pkgName "one", pkgName "two"]) {- Helper functions below -} -- Backport from QuickCheck 2.8 to 2.7.6 sublistOf :: [a] -> Gen [a] sublistOf = filterM (\_ -> choose (False, True)) -- Unsafe internal helper to create a package name pkgName :: Text -> PackageName pkgName = fromMaybe failure . parsePackageName where failure = error "Internal error during package name creation in DotSpec.pkgName" -- Stub, simulates the function to load package dependecies stubLoader :: PackageName -> Identity (Set PackageName, DotPayload) stubLoader name = return . (, dummyPayload) . Set.fromList . map pkgName $ case show name of "StateVar" -> ["stm","transformers"] "array" -> [] "bifunctors" -> ["semigroupoids","semigroups","tagged"] "binary" -> ["array","bytestring","containers"] "bytestring" -> ["deepseq","ghc-prim","integer-gmp"] "comonad" -> ["containers","contravariant","distributive" ,"semigroups","tagged","transformers","transformers-compat" ] "cont" -> ["StateVar","semigroups","transformers","transformers-compat","void"] "containers" -> ["array","deepseq","ghc-prim"] "deepseq" -> ["array"] "distributive" -> ["ghc-prim","tagged","transformers","transformers-compat"] "free" -> ["bifunctors","comonad","distributive","mtl" ,"prelude-extras","profunctors","semigroupoids" ,"semigroups","template-haskell","transformers" ] "ghc" -> [] "hashable" -> ["bytestring","ghc-prim","integer-gmp","text"] "integer" -> [] "mtl" -> ["transformers"] "nats" -> [] "one" -> ["free"] "prelude" -> [] "profunctors" -> ["comonad","distributive","semigroupoids","tagged","transformers"] "semigroupoids" -> ["comonad","containers","contravariant","distributive" ,"semigroups","transformers","transformers-compat" ] "semigroups" -> ["bytestring","containers","deepseq","hashable" ,"nats","text","unordered-containers" ] "stm" -> ["array"] "tagged" -> ["template-haskell"] "template" -> [] "text" -> ["array","binary","bytestring","deepseq","ghc-prim","integer-gmp"] "transformers" -> [] "two" -> ["free","mtl","one","transformers"] "unordered" -> ["deepseq","hashable"] "void" -> ["ghc-prim","hashable","semigroups"] _ -> [] stack-1.9.3.1/src/test/Stack/Ghci/PortableFakePaths.hs0000644000000000000000000000047313015755774020560 0ustar0000000000000000{-# LANGUAGE CPP #-} -- | Helpers for writing fake paths for test suite for the GhciScript DSL. -- This must be a separate module because it is used in Teplate Haskell splices. module Stack.Ghci.PortableFakePaths where defaultDrive :: FilePath #ifdef WINDOWS defaultDrive = "C:\\" #else defaultDrive = "/" #endif stack-1.9.3.1/src/test/Stack/Ghci/ScriptSpec.hs0000644000000000000000000000514313312026775017267 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude #-} {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE OverloadedLists #-} {-# LANGUAGE TemplateHaskell #-} -- | Test suite for the GhciScript DSL module Stack.Ghci.ScriptSpec where import qualified Data.Set as S import Distribution.ModuleName import Test.Hspec import qualified System.FilePath as FP import Stack.Ghci.PortableFakePaths import Stack.Prelude hiding (fromString) import Path import Path.Extra (pathToLazyByteString) import Stack.Ghci.Script spec :: Spec spec = do describe "GHCi" $ do describe "Script DSL" $ do describe "script" $ do it "should seperate commands with a newline" $ do let dir = $(mkAbsDir $ defaultDrive FP. "src" FP. "package-a") script = cmdCdGhc dir <> cmdAdd [Left (fromString "Lib.A")] scriptToLazyByteString script `shouldBe` ":cd-ghc " <> pathToLazyByteString dir <> "\n:add Lib.A\n" describe ":add" $ do it "should not render empty add commands" $ do let script = cmdAdd S.empty scriptToLazyByteString script `shouldBe` "" it "should ensure that a space exists between each module in an add command" $ do let script = cmdAdd (S.fromList [Left (fromString "Lib.A"), Left (fromString "Lib.B")]) scriptToLazyByteString script `shouldBe` ":add Lib.A Lib.B\n" describe ":add (by file)" $ do it "should render a full file path" $ do let file = $(mkAbsFile $ defaultDrive FP. "Users" FP. "someone" FP. "src" FP. "project" FP. "package-a" FP. "src" FP. "Main.hs") script = cmdAdd (S.fromList [Right file]) scriptToLazyByteString script `shouldBe` ":add " <> pathToLazyByteString file <> "\n" describe ":cd-ghc" $ do it "should render a full absolute path" $ do let dir = $(mkAbsDir $ defaultDrive FP. "Users" FP. "someone" FP. "src" FP. "project" FP. "package-a") script = cmdCdGhc dir scriptToLazyByteString script `shouldBe` ":cd-ghc " <> pathToLazyByteString dir <> "\n" describe ":module" $ do it "should render empty module as ':module +'" $ do let script = cmdModule [] scriptToLazyByteString script `shouldBe` ":module +\n" it "should ensure that a space exists between each module in a module command" $ do let script = cmdModule [fromString "Lib.A", fromString "Lib.B"] scriptToLazyByteString script `shouldBe` ":module + Lib.A Lib.B\n" stack-1.9.3.1/src/test/Stack/GhciSpec.hs0000644000000000000000000002217513455617610016031 0ustar0000000000000000-- {-# LANGUAGE NoImplicitPrelude #-} -- {-# LANGUAGE QuasiQuotes #-} -- {-# LANGUAGE TemplateHaskell #-} -- | Test suite for GHCi like applications including both GHCi and Intero. module Stack.GhciSpec where import Test.Hspec spec :: Spec spec = return () {- Commented out as part of the fix for https://github.com/commercialhaskell/stack/issues/3309 Not sure if maintaining this test is worth the effort. import qualified Data.ByteString.Lazy as LBS import qualified Data.Map as M import qualified Data.Set as S import qualified Data.Text as T import qualified Data.Text.Encoding as T import Distribution.License (License (BSD3)) import qualified Distribution.ModuleName as ModuleName import Distribution.PackageDescription (BuildType(..)) import Stack.Prelude import Stack.Types.Package import Stack.Types.PackageName import Stack.Types.Version import Test.Hspec import NeatInterpolation import Path import Path.Extra (pathToText) import qualified System.FilePath as FP import Stack.Ghci import Stack.Ghci.Script (scriptToLazyByteString) import Stack.Ghci.PortableFakePaths textToLazy :: Text -> LBS.ByteString textToLazy = LBS.fromStrict . T.encodeUtf8 -- | Matches two strings, after converting line-ends in the second to Unix ones -- (in a hacky way) and converting both to the same type. Workaround for -- https://github.com/nikita-volkov/neat-interpolation/issues/14. shouldBeLE :: LBS.ByteString -> Text -> Expectation shouldBeLE actual expected = shouldBe actual (textToLazy $ T.filter (/= '\r') expected) baseProjDir, projDirA, projDirB :: Path Abs Dir baseProjDir = $(mkAbsDir $ defaultDrive FP. "Users" FP. "someone" FP. "src") projDirA = baseProjDir $(mkRelDir "project-a") projDirB = baseProjDir $(mkRelDir "project-b") relFile :: Path Rel File relFile = $(mkRelFile $ "exe" FP. "Main.hs") absFile :: Path Abs File absFile = projDirA relFile projDirAT, projDirBT, relFileT, absFileT :: Text projDirAT = pathToText projDirA projDirBT = pathToText projDirB relFileT = pathToText relFile absFileT = pathToText absFile spec :: Spec spec = do describe "GHCi" $ do describe "Script rendering" $ do describe "should render GHCi scripts" $ do it "with one library package" $ do let res = scriptToLazyByteString $ renderScriptGhci packages_singlePackage Nothing [] res `shouldBeLE` ghciScript_projectWithLib it "with one main package" $ do let res = scriptToLazyByteString $ renderScriptGhci [] (Just absFile) [] res `shouldBeLE` ghciScript_projectWithMain it "with one library and main package" $ do let res = scriptToLazyByteString $ renderScriptGhci packages_singlePackage (Just absFile) [] res `shouldBeLE` ghciScript_projectWithLibAndMain it "with multiple library packages" $ do let res = scriptToLazyByteString $ renderScriptGhci packages_multiplePackages Nothing [] res `shouldBeLE` ghciScript_multipleProjectsWithLib describe "should render intero scripts" $ do it "with one library package" $ do let res = scriptToLazyByteString $ renderScriptIntero packages_singlePackage Nothing [] res `shouldBeLE` interoScript_projectWithLib it "with one main package" $ do let res = scriptToLazyByteString $ renderScriptIntero packages_singlePackage (Just absFile) [] res `shouldBeLE` interoScript_projectWithMain it "with one library and main package" $ do let res = scriptToLazyByteString $ renderScriptIntero packages_singlePackage (Just absFile) [] res `shouldBeLE` interoScript_projectWithLibAndMain it "with multiple library packages" $ do let res = scriptToLazyByteString $ renderScriptIntero packages_multiplePackages Nothing [] res `shouldBeLE` interoScript_multipleProjectsWithLib -- Exptected Intero scripts interoScript_projectWithLib :: Text interoScript_projectWithLib = [text| :cd-ghc $projDirAT :add Lib.A :module + Lib.A |] interoScript_projectWithMain :: Text interoScript_projectWithMain = [text| :cd-ghc $projDirAT :add Lib.A :cd-ghc $projDirAT :add $absFileT :module + Lib.A |] interoScript_projectWithLibAndMain :: Text interoScript_projectWithLibAndMain = [text| :cd-ghc $projDirAT :add Lib.A :cd-ghc $projDirAT :add $absFileT :module + Lib.A |] interoScript_multipleProjectsWithLib :: Text interoScript_multipleProjectsWithLib = [text| :cd-ghc $projDirAT :add Lib.A :cd-ghc $projDirBT :add Lib.B :module + Lib.A Lib.B |] -- Expected GHCi Scripts ghciScript_projectWithLib :: Text ghciScript_projectWithLib = [text| :add Lib.A :module + Lib.A |] ghciScript_projectWithMain :: Text ghciScript_projectWithMain = [text| :add $absFileT :module + |] ghciScript_projectWithLibAndMain :: Text ghciScript_projectWithLibAndMain = [text| :add Lib.A :add $absFileT :module + Lib.A |] ghciScript_multipleProjectsWithLib :: Text ghciScript_multipleProjectsWithLib = [text| :add Lib.A :add Lib.B :module + Lib.A Lib.B |] -- Expected Legacy GHCi scripts ghciLegacyScript_projectWithMain :: Text ghciLegacyScript_projectWithMain = [text| :add :add $absFileT :module + |] ghciLegacyScript_projectWithLibAndMain :: Text ghciLegacyScript_projectWithLibAndMain = [text| :add Lib.A :add $absFileT :module + Lib.A |] ghciLegacyScript_multipleProjectsWithLib :: Text ghciLegacyScript_multipleProjectsWithLib = [text| :add Lib.A Lib.B :module + Lib.A Lib.B |] -- Sample GHCi load configs packages_singlePackage :: [GhciPkgInfo] packages_singlePackage = [ GhciPkgInfo { ghciPkgModules = S.fromList [ModuleName.fromString "Lib.A"] , ghciPkgDir = projDirA , ghciPkgName = $(mkPackageName "package-a") , ghciPkgOpts = [] , ghciPkgModFiles = S.empty , ghciPkgCFiles = S.empty , ghciPkgMainIs = M.empty , ghciPkgTargetFiles = Nothing , ghciPkgPackage = Package { packageName = $(mkPackageName "package-a") , packageVersion = $(mkVersion "0.1.0.0") , packageLicense = BSD3 , packageFiles = GetPackageFiles undefined , packageDeps = M.empty , packageTools = [] , packageAllDeps = S.empty , packageGhcOptions = [] , packageFlags = M.empty , packageDefaultFlags = M.empty , packageHasLibrary = True , packageTests = M.empty , packageBenchmarks = S.empty , packageExes = S.empty , packageOpts = GetPackageOpts undefined , packageHasExposedModules = True , packageBuildType = Just Simple , packageSetupDeps = Nothing } } ] packages_multiplePackages :: [GhciPkgInfo] packages_multiplePackages = [ GhciPkgInfo { ghciPkgModules = S.fromList [ModuleName.fromString "Lib.A"] , ghciPkgDir = projDirA , ghciPkgName = $(mkPackageName "package-a") , ghciPkgOpts = [] , ghciPkgModFiles = S.empty , ghciPkgCFiles = S.empty , ghciPkgMainIs = M.empty , ghciPkgTargetFiles = Nothing , ghciPkgPackage = Package { packageName = $(mkPackageName "package-a") , packageVersion = $(mkVersion "0.1.0.0") , packageLicense = BSD3 , packageFiles = GetPackageFiles undefined , packageDeps = M.empty , packageTools = [] , packageAllDeps = S.empty , packageGhcOptions = [] , packageFlags = M.empty , packageDefaultFlags = M.empty , packageHasLibrary = True , packageTests = M.empty , packageBenchmarks = S.empty , packageExes = S.empty , packageOpts = GetPackageOpts undefined , packageHasExposedModules = True , packageBuildType = Just Simple , packageSetupDeps = Nothing } } , GhciPkgInfo { ghciPkgModules = S.fromList [ModuleName.fromString "Lib.B"] , ghciPkgDir = projDirB , ghciPkgName = $(mkPackageName "package-b") , ghciPkgOpts = [] , ghciPkgModFiles = S.empty , ghciPkgCFiles = S.empty , ghciPkgMainIs = M.empty , ghciPkgTargetFiles = Nothing , ghciPkgPackage = Package { packageName = $(mkPackageName "package-b") , packageVersion = $(mkVersion "0.1.0.0") , packageLicense = BSD3 , packageFiles = GetPackageFiles undefined , packageDeps = M.empty , packageTools = [] , packageAllDeps = S.empty , packageGhcOptions = [] , packageFlags = M.empty , packageDefaultFlags = M.empty , packageHasLibrary = True , packageTests = M.empty , packageBenchmarks = S.empty , packageExes = S.empty , packageOpts = GetPackageOpts undefined , packageHasExposedModules = True , packageBuildType = Just Simple , packageSetupDeps = Nothing } } ] -} stack-1.9.3.1/src/test/Stack/NixSpec.hs0000644000000000000000000001035413455617610015711 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude #-} {-# LANGUAGE FlexibleContexts #-} {-# LANGUAGE OverloadedStrings #-} module Stack.NixSpec where import Data.Maybe (fromJust) import Options.Applicative import Path import Prelude (writeFile) import Stack.Config import Stack.Config.Nix import Stack.Constants import Stack.Options.NixParser import Stack.Prelude import Stack.Types.Compiler import Stack.Types.Config import Stack.Types.Nix import Stack.Types.Runner import Stack.Types.Version import System.Directory import System.Environment import Test.Hspec sampleConfigNixEnabled :: String sampleConfigNixEnabled = "resolver: lts-2.10\n" ++ "packages: ['.']\n" ++ "system-ghc: true\n" ++ "nix:\n" ++ " enable: True\n" ++ " packages: [glpk]" sampleConfigNixDisabled :: String sampleConfigNixDisabled = "resolver: lts-2.10\n" ++ "packages: ['.']\n" ++ "nix:\n" ++ " enable: False" setup :: IO () setup = unsetEnv "STACK_YAML" spec :: Spec spec = beforeAll setup $ do let loadConfig' cmdLineArgs = withRunner LevelDebug True False ColorAuto Nothing False $ \runner -> runRIO runner $ loadConfig cmdLineArgs Nothing SYLDefault inTempDir test = do currentDirectory <- getCurrentDirectory withSystemTempDirectory "Stack_ConfigSpec" $ \tempDir -> do let enterDir = setCurrentDirectory tempDir exitDir = setCurrentDirectory currentDirectory bracket_ enterDir exitDir test withStackDotYaml config test = inTempDir $ do writeFile (toFilePath stackDotYaml) config test parseNixOpts cmdLineOpts = fromJust $ getParseResult $ execParserPure defaultPrefs (info (nixOptsParser False) mempty) cmdLineOpts parseOpts cmdLineOpts = mempty { configMonoidNixOpts = parseNixOpts cmdLineOpts } let trueOnNonWindows = not osIsWindows describe "nix disabled in config file" $ around_ (withStackDotYaml sampleConfigNixDisabled) $ do it "sees that the nix shell is not enabled" $ do lc <- loadConfig' mempty nixEnable (configNix $ lcConfig lc) `shouldBe` False describe "--nix given on command line" $ it "sees that the nix shell is enabled" $ do lc <- loadConfig' (parseOpts ["--nix"]) nixEnable (configNix $ lcConfig lc) `shouldBe` trueOnNonWindows describe "--nix-pure given on command line" $ it "sees that the nix shell is enabled" $ do lc <- loadConfig' (parseOpts ["--nix-pure"]) nixEnable (configNix $ lcConfig lc) `shouldBe` trueOnNonWindows describe "--no-nix given on command line" $ it "sees that the nix shell is not enabled" $ do lc <- loadConfig' (parseOpts ["--no-nix"]) nixEnable (configNix $ lcConfig lc) `shouldBe` False describe "--no-nix-pure given on command line" $ it "sees that the nix shell is not enabled" $ do lc <- loadConfig' (parseOpts ["--no-nix-pure"]) nixEnable (configNix $ lcConfig lc) `shouldBe` False describe "nix enabled in config file" $ around_ (withStackDotYaml sampleConfigNixEnabled) $ do it "sees that the nix shell is enabled" $ do lc <- loadConfig' mempty nixEnable (configNix $ lcConfig lc) `shouldBe` trueOnNonWindows describe "--no-nix given on command line" $ it "sees that the nix shell is not enabled" $ do lc <- loadConfig' (parseOpts ["--no-nix"]) nixEnable (configNix $ lcConfig lc) `shouldBe` False describe "--nix-pure given on command line" $ it "sees that the nix shell is enabled" $ do lc <- loadConfig' (parseOpts ["--nix-pure"]) nixEnable (configNix $ lcConfig lc) `shouldBe` trueOnNonWindows describe "--no-nix-pure given on command line" $ it "sees that the nix shell is enabled" $ do lc <- loadConfig' (parseOpts ["--no-nix-pure"]) nixEnable (configNix $ lcConfig lc) `shouldBe` trueOnNonWindows it "sees that the only package asked for is glpk and asks for the correct GHC derivation" $ do lc <- loadConfig' mempty nixPackages (configNix $ lcConfig lc) `shouldBe` ["glpk"] v <- parseVersion "7.10.3" ghc <- either throwIO return $ nixCompiler (GhcVersion v) ghc `shouldBe` "haskell.compiler.ghc7103" stack-1.9.3.1/src/test/Stack/PackageDumpSpec.hs0000644000000000000000000003106613455617610017337 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude #-} {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TemplateHaskell #-} {-# LANGUAGE TupleSections #-} module Stack.PackageDumpSpec where import Data.Conduit import qualified Data.Conduit.List as CL import Data.Conduit.Text (decodeUtf8) import qualified Data.Map as Map import qualified Data.Set as Set import Distribution.License (License(..)) import Stack.PackageDump import Stack.Prelude import Stack.Types.Compiler import Stack.Types.GhcPkgId import Stack.Types.PackageIdentifier import Stack.Types.PackageName import Stack.Types.Version import RIO.Process import Test.Hspec import Test.Hspec.QuickCheck main :: IO () main = hspec spec spec :: Spec spec = do describe "eachSection" $ do let test name content expected = it name $ do actual <- runConduit $ yield content .| eachSection CL.consume .| CL.consume actual `shouldBe` expected test "unix line endings" "foo\nbar\n---\nbaz---\nbin\n---\n" [ ["foo", "bar"] , ["baz---", "bin"] ] test "windows line endings" "foo\r\nbar\r\n---\r\nbaz---\r\nbin\r\n---\r\n" [ ["foo", "bar"] , ["baz---", "bin"] ] it "eachPair" $ do let bss = [ "key1: val1" , "key2: val2a" , " val2b" , "key3:" , "key4:" , " val4a" , " val4b" ] sink k = fmap (k, ) CL.consume actual <- runConduit $ mapM_ yield bss .| eachPair sink .| CL.consume actual `shouldBe` [ ("key1", ["val1"]) , ("key2", ["val2a", "val2b"]) , ("key3", []) , ("key4", ["val4a", "val4b"]) ] describe "conduitDumpPackage" $ do it "ghc 7.8" $ do haskell2010:_ <- withSourceFile "test/package-dump/ghc-7.8.txt" $ \src -> runConduit $ src .| decodeUtf8 .| conduitDumpPackage .| CL.consume ghcPkgId <- parseGhcPkgId "haskell2010-1.1.2.0-05c8dd51009e08c6371c82972d40f55a" packageIdent <- parsePackageIdentifier "haskell2010-1.1.2.0" depends <- mapM parseGhcPkgId [ "array-0.5.0.0-470385a50d2b78598af85cfe9d988e1b" , "base-4.7.0.2-bfd89587617e381ae01b8dd7b6c7f1c1" , "ghc-prim-0.3.1.0-a24f9c14c632d75b683d0f93283aea37" ] haskell2010 { dpExposedModules = [] } `shouldBe` DumpPackage { dpGhcPkgId = ghcPkgId , dpPackageIdent = packageIdent , dpParentLibIdent = Nothing , dpLicense = Just BSD3 , dpLibDirs = ["/opt/ghc/7.8.4/lib/ghc-7.8.4/haskell2010-1.1.2.0"] , dpDepends = depends , dpLibraries = ["HShaskell2010-1.1.2.0"] , dpHasExposedModules = True , dpHaddockInterfaces = ["/opt/ghc/7.8.4/share/doc/ghc/html/libraries/haskell2010-1.1.2.0/haskell2010.haddock"] , dpHaddockHtml = Just "/opt/ghc/7.8.4/share/doc/ghc/html/libraries/haskell2010-1.1.2.0" , dpProfiling = () , dpHaddock = () , dpSymbols = () , dpIsExposed = False , dpExposedModules = [] } it "ghc 7.10" $ do haskell2010:_ <- withSourceFile "test/package-dump/ghc-7.10.txt" $ \src -> runConduit $ src .| decodeUtf8 .| conduitDumpPackage .| CL.consume ghcPkgId <- parseGhcPkgId "ghc-7.10.1-325809317787a897b7a97d646ceaa3a3" pkgIdent <- parsePackageIdentifier "ghc-7.10.1" depends <- mapM parseGhcPkgId [ "array-0.5.1.0-e29cdbe82692341ebb7ce6e2798294f9" , "base-4.8.0.0-1b689eb8d72c4d4cc88f445839c1f01a" , "bin-package-db-0.0.0.0-708fc7d634a370b311371a5bcde40b62" , "bytestring-0.10.6.0-0909f8f31271f3d75749190bf2ee35db" , "containers-0.5.6.2-2114032c163425cc264e6e1169dc2f6d" , "directory-1.2.2.0-b4959b472d9eee380c6b32291ade29e0" , "filepath-1.4.0.0-40d643aa87258c186441a1f8f3e13ca6" , "hoopl-3.10.0.2-8c8dfc4c3140e5f7c982da224c3cb1f0" , "hpc-0.6.0.2-ac9064885aa8cb08a93314222939ead4" , "process-1.2.3.0-3b1e9bca6ac38225806ff7bbf3f845b1" , "template-haskell-2.10.0.0-e895139a0ffff267d412e3d0191ce93b" , "time-1.5.0.1-e17a9220d438435579d2914e90774246" , "transformers-0.4.2.0-c1a7bb855a176fe475d7b665301cd48f" , "unix-2.7.1.0-e5915eb989e568b732bc7286b0d0817f" ] haskell2010 { dpExposedModules = [] } `shouldBe` DumpPackage { dpGhcPkgId = ghcPkgId , dpPackageIdent = pkgIdent , dpParentLibIdent = Nothing , dpLicense = Just BSD3 , dpLibDirs = ["/opt/ghc/7.10.1/lib/ghc-7.10.1/ghc_EMlWrQ42XY0BNVbSrKixqY"] , dpHaddockInterfaces = ["/opt/ghc/7.10.1/share/doc/ghc/html/libraries/ghc-7.10.1/ghc.haddock"] , dpHaddockHtml = Just "/opt/ghc/7.10.1/share/doc/ghc/html/libraries/ghc-7.10.1" , dpDepends = depends , dpLibraries = ["HSghc-7.10.1-EMlWrQ42XY0BNVbSrKixqY"] , dpHasExposedModules = True , dpProfiling = () , dpHaddock = () , dpSymbols = () , dpIsExposed = False , dpExposedModules = [] } it "ghc 7.8.4 (osx)" $ do hmatrix:_ <- withSourceFile "test/package-dump/ghc-7.8.4-osx.txt" $ \src -> runConduit $ src .| decodeUtf8 .| conduitDumpPackage .| CL.consume ghcPkgId <- parseGhcPkgId "hmatrix-0.16.1.5-12d5d21f26aa98774cdd8edbc343fbfe" pkgId <- parsePackageIdentifier "hmatrix-0.16.1.5" depends <- mapM parseGhcPkgId [ "array-0.5.0.0-470385a50d2b78598af85cfe9d988e1b" , "base-4.7.0.2-918c7ac27f65a87103264a9f51652d63" , "binary-0.7.1.0-108d06eea2ef05e517f9c1facf10f63c" , "bytestring-0.10.4.0-78bc8f2c724c765c78c004a84acf6cc3" , "deepseq-1.3.0.2-0ddc77716bd2515426e1ba39f6788a4f" , "random-1.1-822c19b7507b6ac1aaa4c66731e775ae" , "split-0.2.2-34cfb851cc3784e22bfae7a7bddda9c5" , "storable-complex-0.2.2-e962c368d58acc1f5b41d41edc93da72" , "vector-0.10.12.3-f4222db607fd5fdd7545d3e82419b307"] hmatrix `shouldBe` DumpPackage { dpGhcPkgId = ghcPkgId , dpPackageIdent = pkgId , dpParentLibIdent = Nothing , dpLicense = Just BSD3 , dpLibDirs = [ "/Users/alexbiehl/.stack/snapshots/x86_64-osx/lts-2.13/7.8.4/lib/x86_64-osx-ghc-7.8.4/hmatrix-0.16.1.5" , "/opt/local/lib/" , "/usr/local/lib/" , "C:/Program Files/Example/"] , dpHaddockInterfaces = ["/Users/alexbiehl/.stack/snapshots/x86_64-osx/lts-2.13/7.8.4/doc/html/hmatrix.haddock"] , dpHaddockHtml = Just "/Users/alexbiehl/.stack/snapshots/x86_64-osx/lts-2.13/7.8.4/doc/html" , dpDepends = depends , dpLibraries = ["HShmatrix-0.16.1.5"] , dpHasExposedModules = True , dpProfiling = () , dpHaddock = () , dpSymbols = () , dpIsExposed = True , dpExposedModules = ["Data.Packed","Data.Packed.Vector","Data.Packed.Matrix","Data.Packed.Foreign","Data.Packed.ST","Data.Packed.Development","Numeric.LinearAlgebra","Numeric.LinearAlgebra.LAPACK","Numeric.LinearAlgebra.Algorithms","Numeric.Container","Numeric.LinearAlgebra.Util","Numeric.LinearAlgebra.Devel","Numeric.LinearAlgebra.Data","Numeric.LinearAlgebra.HMatrix","Numeric.LinearAlgebra.Static"] } it "ghc HEAD" $ do ghcBoot:_ <- withSourceFile "test/package-dump/ghc-head.txt" $ \src -> runConduit $ src .| decodeUtf8 .| conduitDumpPackage .| CL.consume ghcPkgId <- parseGhcPkgId "ghc-boot-0.0.0.0" pkgId <- parsePackageIdentifier "ghc-boot-0.0.0.0" depends <- mapM parseGhcPkgId [ "base-4.9.0.0" , "binary-0.7.5.0" , "bytestring-0.10.7.0" , "directory-1.2.5.0" , "filepath-1.4.1.0" ] ghcBoot `shouldBe` DumpPackage { dpGhcPkgId = ghcPkgId , dpPackageIdent = pkgId , dpParentLibIdent = Nothing , dpLicense = Just BSD3 , dpLibDirs = ["/opt/ghc/head/lib/ghc-7.11.20151213/ghc-boot-0.0.0.0"] , dpHaddockInterfaces = ["/opt/ghc/head/share/doc/ghc/html/libraries/ghc-boot-0.0.0.0/ghc-boot.haddock"] , dpHaddockHtml = Just "/opt/ghc/head/share/doc/ghc/html/libraries/ghc-boot-0.0.0.0" , dpDepends = depends , dpLibraries = ["HSghc-boot-0.0.0.0"] , dpHasExposedModules = True , dpProfiling = () , dpHaddock = () , dpSymbols = () , dpIsExposed = True , dpExposedModules = ["GHC.Lexeme", "GHC.PackageDb"] } it "ghcPkgDump + addProfiling + addHaddock" $ runEnvNoLogging $ do icache <- newInstalledCache ghcPkgDump Ghc [] $ conduitDumpPackage .| addProfiling icache .| addHaddock icache .| fakeAddSymbols .| CL.sinkNull it "sinkMatching" $ runEnvNoLogging $ do icache <- newInstalledCache m <- ghcPkgDump Ghc [] $ conduitDumpPackage .| addProfiling icache .| addHaddock icache .| fakeAddSymbols .| sinkMatching False False False (Map.singleton $(mkPackageName "transformers") $(mkVersion "0.0.0.0.0.0.1")) case Map.lookup $(mkPackageName "base") m of Nothing -> error "base not present" Just _ -> return () liftIO $ do Map.lookup $(mkPackageName "transformers") m `shouldBe` Nothing Map.lookup $(mkPackageName "ghc") m `shouldBe` Nothing describe "pruneDeps" $ do it "sanity check" $ do let prunes = [ ((1, 'a'), []) , ((1, 'b'), []) , ((2, 'a'), [(1, 'b')]) , ((2, 'b'), [(1, 'a')]) , ((3, 'a'), [(1, 'c')]) , ((4, 'a'), [(2, 'a')]) ] actual = fst <$> pruneDeps fst fst snd bestPrune prunes actual `shouldBe` Map.fromList [ (1, (1, 'b')) , (2, (2, 'a')) , (4, (4, 'a')) ] prop "invariant holds" $ \prunes' -> -- Force uniqueness let prunes = Map.toList $ Map.fromList prunes' in checkDepsPresent prunes $ fst <$> pruneDeps fst fst snd bestPrune prunes type PruneCheck = ((Int, Char), [(Int, Char)]) bestPrune :: PruneCheck -> PruneCheck -> PruneCheck bestPrune x y | fst x > fst y = x | otherwise = y checkDepsPresent :: [PruneCheck] -> Map Int (Int, Char) -> Bool checkDepsPresent prunes selected = all hasDeps $ Set.toList allIds where depMap = Map.fromList prunes allIds = Set.fromList $ Map.elems selected hasDeps ident = case Map.lookup ident depMap of Nothing -> error "checkDepsPresent: missing in depMap" Just deps -> Set.null $ Set.difference (Set.fromList deps) allIds -- addSymbols can't be reasonably tested like this fakeAddSymbols :: Monad m => ConduitM (DumpPackage a b c) (DumpPackage a b Bool) m () fakeAddSymbols = CL.map (\dp -> dp { dpSymbols = False }) runEnvNoLogging :: RIO LoggedProcessContext a -> IO a runEnvNoLogging inner = do envVars <- view envVarsL <$> mkDefaultProcessContext menv <- mkProcessContext $ Map.delete "GHC_PACKAGE_PATH" envVars runRIO (LoggedProcessContext menv mempty) inner stack-1.9.3.1/src/test/Stack/SolverSpec.hs0000644000000000000000000000301213455617610016416 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude #-} {-# LANGUAGE TemplateHaskell #-} {-# LANGUAGE OverloadedStrings #-} -- | Test suite for "Stack.Solver" module Stack.SolverSpec where import Data.Text (unpack) import Stack.Prelude import Stack.Types.FlagName import Stack.Types.PackageName import Stack.Types.Version import Test.Hspec import qualified Data.Map as Map import Stack.Solver spec :: Spec spec = describe "Stack.Solver" $ do successfulExample "text-1.2.1.1 (latest: 1.2.2.0) -integer-simple (via: parsec-3.1.9) (new package)" $(mkPackageName "text") $(mkVersion "1.2.1.1") [ ($(mkFlagName "integer-simple"), False) ] successfulExample "hspec-snap-1.0.0.0 *test (via: servant-snap-0.5) (new package)" $(mkPackageName "hspec-snap") $(mkVersion "1.0.0.0") [] successfulExample "time-locale-compat-0.1.1.1 -old-locale (via: http-api-data-0.2.2) (new package)" $(mkPackageName "time-locale-compat") $(mkVersion "0.1.1.1") [ ($(mkFlagName "old-locale"), False) ] successfulExample "flowdock-rest-0.2.0.0 -aeson-compat *test (via: haxl-fxtra-0.0.0.0) (new package)" $(mkPackageName "flowdock-rest") $(mkVersion "0.2.0.0") [ ($(mkFlagName "aeson-compat"), False) ] where successfulExample input pkgName pkgVersion flags = it ("parses " ++ unpack input) $ parseCabalOutputLine input `shouldBe` Right (pkgName, (pkgVersion, Map.fromList flags)) stack-1.9.3.1/src/test/Stack/StaticBytesSpec.hs0000644000000000000000000000532013455617610017406 0ustar0000000000000000{-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE NoImplicitPrelude #-} module Stack.StaticBytesSpec (spec) where import Stack.StaticBytes import Stack.Prelude import qualified Data.ByteString as B import qualified Data.Vector.Unboxed as VU import qualified Data.Vector.Primitive as VP import qualified Data.Vector.Storable as VS import Test.Hspec import Test.Hspec.QuickCheck import qualified Data.Text as T import qualified Data.Text.Encoding as TE spec :: Spec spec = do describe "ByteString" $ tests B.pack describe "Storable Vector" $ tests VS.fromList describe "Unboxed Vector" $ tests VU.fromList describe "Primitive Vector" $ tests VP.fromList tests :: (Eq dbytes, Show dbytes, DynamicBytes dbytes) => ([Word8] -> dbytes) -> Spec tests pack = do it "disallows 4 bytes" $ do toStaticExact (pack [1..4]) `shouldBe` (Left NotEnoughBytes :: Either StaticBytesException Bytes8) it "toStaticExact matches ByteString" $ do let octets = [1..8] (expected :: Bytes8) = either impureThrow id $ toStaticExact (B.pack octets) actual = either impureThrow id $ toStaticExact (pack octets) actual `shouldBe` expected it "fromStatic round trips" $ do let octets = [1..8] v1 = pack octets (b8 :: Bytes8) = either impureThrow id $ toStaticExact v1 v2 = fromStatic b8 v2 `shouldBe` v1 it "allows 8 bytes" $ do let bs = pack [1..8] case toStaticExact bs of Left e -> throwIO e Right b8 -> fromStatic (b8 :: Bytes8) `shouldBe` bs toStaticExact bs `shouldBe` (Left NotEnoughBytes :: Either StaticBytesException Bytes16) it "padding is the same as trailing nulls" $ do let bs1 = pack $ [1..4] ++ replicate 4 0 bs2 = pack [1..4] Right (toStaticPadTruncate bs2 :: Bytes8) `shouldBe` toStaticExact bs1 prop "handles bytes16" $ \octets -> do let bs = pack $ take 16 octets (b16 :: Bytes16) = either impureThrow id $ toStaticPad bs fromStatic b16 `shouldBe` pack (take 16 (octets ++ replicate 16 0)) it "spot check bytes16" $ do let bs = pack $ replicate 16 0 (b16 :: Bytes16) = either impureThrow id $ toStaticPad bs fromStatic b16 `shouldBe` pack (replicate 16 0) prop "handles bytes32" $ \octets -> do let bs = pack $ take 32 octets (b32 :: Bytes32) = either impureThrow id $ toStaticPad bs fromStatic b32 `shouldBe` pack (take 32 (take 32 octets ++ replicate 32 0)) prop "fuzz with encodeUtf8" $ \chars -> do let t = T.pack $ filter (/= '\0') chars bs = TE.encodeUtf8 t bs128 = pack $ B.unpack $ B.take 128 $ bs `B.append` B.replicate 128 0 b128 = toStaticPadTruncate (pack $ B.unpack bs) :: Bytes128 fromStatic b128 `shouldBe` bs128 stack-1.9.3.1/src/test/Stack/StoreSpec.hs0000644000000000000000000000540213455617610016245 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude #-} {-# OPTIONS_GHC -fno-warn-orphans -Wwarn #-} {-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE MultiParamTypeClasses #-} {-# LANGUAGE RankNTypes #-} {-# LANGUAGE TemplateHaskell #-} {-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE OverloadedStrings #-} module Stack.StoreSpec where import qualified Data.ByteString as BS import Data.Containers (mapFromList, setFromList) import Data.Sequences (fromList) import Data.Store.Internal (StaticSize (..)) import Data.Store.TH import qualified Data.Vector.Unboxed as UV import GHC.TypeLits (KnownNat) import Language.Haskell.TH import Language.Haskell.TH.ReifyMany import Stack.Prelude import Stack.Types.Build import Stack.Types.PackageDump import Test.Hspec import Test.SmallCheck.Series -- NOTE: these were copied from Data.Store. Should probably be moved to -- smallcheck. instance (Monad m, Serial m k, Serial m a, Ord k) => Serial m (Map k a) where series = fmap mapFromList series instance (Monad m, Serial m k, Serial m a, Eq k, Hashable k) => Serial m (HashMap k a) where series = fmap mapFromList series instance Monad m => Serial m Text where series = fmap fromList series instance (Monad m, Serial m a, UV.Unbox a) => Serial m (UV.Vector a) where series = fmap fromList series instance Monad m => Serial m BS.ByteString where series = fmap BS.pack series instance (Monad m, Serial m a, Ord a) => Serial m (Set a) where series = fmap setFromList series instance (Monad m, KnownNat n) => Serial m (StaticSize n BS.ByteString) addMinAndMaxBounds :: forall a. (Bounded a, Eq a) => [a] -> [a] addMinAndMaxBounds xs = (if (minBound :: a) `notElem` xs then [minBound] else []) ++ (if (maxBound :: a) `notElem` xs && (maxBound :: a) /= minBound then maxBound : xs else xs) $(do let tys = [ ''InstalledCacheInner -- FIXME , ''PackageCache -- FIXME , ''LoadedSnapshot , ''BuildCache , ''ConfigCache ] ns <- reifyManyWithoutInstances ''Serial tys (`notElem` [''UV.Vector]) let f n = [d| instance Monad m => Serial m $(conT n) |] concat <$> mapM f ns) verbose :: Bool verbose = False spec :: Spec spec = do describe "Roundtrips binary formats" $ do $(smallcheckManyStore False 6 [ [t| InstalledCacheInner |] , [t| BuildCache |] ]) -- Blows up with > 5 {- $(smallcheckManyStore False 5 [ -- FIXME [t| PackageCache |] -- FIXME , [t| LoadedSnapshot |] ]) -} -- Blows up with > 4 $(smallcheckManyStore False 4 [ [t| ConfigCache |] ]) stack-1.9.3.1/src/test/Stack/Types/BuildPlanSpec.hs0000644000000000000000000000626513455617610020137 0ustar0000000000000000{-# LANGUAGE OverloadedStrings #-} module Stack.Types.BuildPlanSpec where import Data.Aeson.Extended (WithJSONWarnings(..)) import Data.ByteString (ByteString) import qualified Data.ByteString.Char8 as S8 import Data.Yaml (decodeThrow) import Stack.Types.BuildPlan import Test.Hspec spec :: Spec spec = describe "PackageLocation" $ do describe "Archive" $ do describe "github" $ do let decode' :: ByteString -> Maybe (WithJSONWarnings (PackageLocation Subdirs)) decode' = decodeThrow it "'github' and 'commit' keys" $ do let contents :: ByteString contents = S8.pack (unlines [ "github: oink/town" , "commit: abc123" ]) let expected :: PackageLocation Subdirs expected = PLArchive Archive { archiveUrl = "https://github.com/oink/town/archive/abc123.tar.gz" , archiveSubdirs = DefaultSubdirs , archiveHash = Nothing } decode' contents `shouldBe` Just (WithJSONWarnings expected []) it "'github', 'commit', and 'subdirs' keys" $ do let contents :: ByteString contents = S8.pack (unlines [ "github: oink/town" , "commit: abc123" , "subdirs:" , " - foo" ]) let expected :: PackageLocation Subdirs expected = PLArchive Archive { archiveUrl = "https://github.com/oink/town/archive/abc123.tar.gz" , archiveSubdirs = ExplicitSubdirs ["foo"] , archiveHash = Nothing } decode' contents `shouldBe` Just (WithJSONWarnings expected []) it "does not parse GitHub repo with no slash" $ do let contents :: ByteString contents = S8.pack (unlines [ "github: oink" , "commit: abc123" ]) decode' contents `shouldBe` Nothing it "does not parse GitHub repo with leading slash" $ do let contents :: ByteString contents = S8.pack (unlines [ "github: /oink" , "commit: abc123" ]) decode' contents `shouldBe` Nothing it "does not parse GitHub repo with trailing slash" $ do let contents :: ByteString contents = S8.pack (unlines [ "github: oink/" , "commit: abc123" ]) decode' contents `shouldBe` Nothing it "does not parse GitHub repo with more than one slash" $ do let contents :: ByteString contents = S8.pack (unlines [ "github: oink/town/here" , "commit: abc123" ]) decode' contents `shouldBe` Nothing stack-1.9.3.1/src/test/Stack/Types/TemplateNameSpec.hs0000644000000000000000000000457013455617610020636 0ustar0000000000000000{-# LANGUAGE OverloadedStrings #-} module Stack.Types.TemplateNameSpec where import Stack.Types.TemplateName import Path.Internal import System.Info (os) import Test.Hspec spec :: Spec spec = describe "TemplateName" $ do describe "parseTemplateNameFromString" $ do let pathOf s = either error templatePath (parseTemplateNameFromString s) it "parses out the TemplatePath" $ do pathOf "github:user/name" `shouldBe` (RepoPath $ RepoTemplatePath Github "user" "name.hsfiles") pathOf "bitbucket:user/name" `shouldBe` (RepoPath $ RepoTemplatePath Bitbucket "user" "name.hsfiles") pathOf "gitlab:user/name" `shouldBe` (RepoPath $ RepoTemplatePath Gitlab "user" "name.hsfiles") pathOf "http://www.com/file" `shouldBe` UrlPath "http://www.com/file" pathOf "https://www.com/file" `shouldBe` UrlPath "https://www.com/file" pathOf "name" `shouldBe` (RelPath $ Path "name.hsfiles") pathOf "name.hsfile" `shouldBe` (RelPath $ Path "name.hsfile.hsfiles") pathOf "name.hsfiles" `shouldBe` (RelPath $ Path "name.hsfiles") pathOf "" `shouldBe` (RelPath $ Path ".hsfiles") if os == "mingw32" then do pathOf "//home/file" `shouldBe` (AbsPath $ Path "\\\\home\\file.hsfiles") pathOf "/home/file" `shouldBe` (RelPath $ Path "\\home\\file.hsfiles") pathOf "/home/file.hsfiles" `shouldBe` (RelPath $ Path "\\home\\file.hsfiles") pathOf "c:\\home\\file" `shouldBe` (AbsPath $ Path "C:\\home\\file.hsfiles") pathOf "with/slash" `shouldBe` (RelPath $ Path "with\\slash.hsfiles") let colonAction = do return $! pathOf "with:colon" colonAction `shouldThrow` anyErrorCall else do pathOf "//home/file" `shouldBe` (AbsPath $ Path "/home/file.hsfiles") pathOf "/home/file" `shouldBe` (AbsPath $ Path "/home/file.hsfiles") pathOf "/home/file.hsfiles" `shouldBe` (AbsPath $ Path "/home/file.hsfiles") pathOf "c:\\home\\file" `shouldBe` (RelPath $ Path "c:\\home\\file.hsfiles") pathOf "with/slash" `shouldBe` (RelPath $ Path "with/slash.hsfiles") pathOf "with:colon" `shouldBe` (RelPath $ Path "with:colon.hsfiles") stack-1.9.3.1/src/test/Stack/Untar/UntarSpec.hs0000644000000000000000000000316213455617610017334 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude #-} {-# LANGUAGE FlexibleContexts #-} {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TemplateHaskell #-} {-# OPTIONS_GHC -fno-warn-orphans #-} module Stack.Untar.UntarSpec where import Data.List (sort) import Path import Path.IO (removeDirRecur) import qualified System.FilePath as FP import Stack.Fetch (untar) import Stack.Prelude import Test.Hspec spec :: Spec spec = do describe "Untarring ignores strange entries" $ mapM_ testTarFile tarFiles where -- XXX tests are run in the project root folder, but data files are next to -- this source data. currentFolder = $(mkRelDir $ "src" FP. "test" FP. "Stack" FP. "Untar") -- Pairs test tarball names + list of unexpected entries contained: for each -- entry, a tar pathname + description. tarFilesBase = [ ("test1", []) , ("test2", [ ("bar", "named pipe") , ("devB", "block device") , ("devC", "character device")])] -- Prepend tarball name to tar pathnames: tarFiles = [ (name, [ (name FP. entryName, d) | (entryName, d) <- entries]) | (name, entries) <- tarFilesBase ] testTarFile (name, expected) = it ("works on test " ++ name) $ getEntries name `shouldReturn` sort expected getEntries name = do tarballName <- parseRelFile $ name ++ ".tar.gz" expectedTarFolder <- parseRelDir name entries <- untar (currentFolder tarballName) expectedTarFolder currentFolder removeDirRecur $ currentFolder expectedTarFolder return $ sort entries stack-1.9.3.1/test/integration/IntegrationSpec.hs0000644000000000000000000001235613455617610020131 0ustar0000000000000000{-# LANGUAGE DeriveDataTypeable #-} {-# LANGUAGE ScopedTypeVariables #-} import Control.Applicative import Control.Arrow import Control.Concurrent.Async import Control.Exception import Control.Monad import Control.Monad.IO.Class import Control.Monad.Trans.Resource import qualified Data.ByteString.Lazy as L import Data.Char import Data.Conduit import Data.Conduit.Binary (sinkLbs) import Data.Conduit.Filesystem (sourceDirectoryDeep) import qualified Data.Conduit.List as CL import Data.Conduit.Process import Data.List (isSuffixOf, stripPrefix, sort) import qualified Data.Map as Map import Data.Maybe (fromMaybe) import Data.Text.Encoding.Error (lenientDecode) import qualified Data.Text.Lazy as TL import qualified Data.Text.Lazy.Encoding as TL import Data.Typeable import Prelude -- Fix redundant import warnings import System.Directory import System.Environment import System.Exit import System.FilePath import System.IO.Temp import System.PosixCompat.Files import Test.Hspec main :: IO () main = do currDir <- canonicalizePath "test/integration" let findExe name = do mexe <- findExecutable name case mexe of Nothing -> error $ name ++ " not found on PATH" Just exe -> return exe runghc <- findExe "runghc" stack <- findExe "stack" let testDir = currDir "tests" tests <- getDirectoryContents testDir >>= filterM (hasTest testDir) . sort envOrig <- getEnvironment withSystemTempDirectory "stackhome" $ \newHome -> do defaultStackRoot <- getAppUserDataDirectory "stack" let newStackRoot = newHome takeFileName defaultStackRoot env' = Map.toList $ Map.insert "STACK_EXE" stack $ Map.insert "HOME" newHome $ Map.insert "APPDATA" newHome $ Map.insert "STACK_ROOT" newStackRoot $ Map.delete "GHC_PACKAGE_PATH" $ Map.fromList $ map (first (map toUpper)) envOrig origStackRoot = fromMaybe defaultStackRoot (lookup "STACK_ROOT" envOrig) hspec $ mapM_ (test runghc env' currDir origStackRoot newHome newStackRoot) tests hasTest :: FilePath -> FilePath -> IO Bool hasTest root dir = doesFileExist $ root dir "Main.hs" test :: FilePath -- ^ runghc -> [(String, String)] -- ^ env -> FilePath -- ^ currdir -> FilePath -- ^ origStackRoot -> FilePath -- ^ newHome -> FilePath -- ^ newStackRoot -> String -> Spec test runghc env' currDir origStackRoot newHome newStackRoot name = it name $ withDir $ \dir -> do newHomeExists <- doesDirectoryExist newHome when newHomeExists (removeDirectoryRecursive newHome) createDirectoryIfMissing True newStackRoot copyTree toCopyRoot origStackRoot newStackRoot writeFile (newStackRoot "config.yaml") "system-ghc: true\ninstall-ghc: false\n" let testDir = currDir "tests" name mainFile = testDir "Main.hs" libDir = currDir "lib" cp = (proc runghc [ "-clear-package-db" , "-global-package-db" , "-i" ++ libDir , mainFile ]) { cwd = Just dir , env = Just env' } copyTree (const True) (testDir "files") dir (ClosedStream, outSrc, errSrc, sph) <- streamingProcess cp (out, err, ec) <- runConcurrently $ (,,) <$> Concurrently (outSrc `connect` sinkLbs) <*> Concurrently (errSrc `connect` sinkLbs) <*> Concurrently (waitForStreamingProcess sph) when (ec /= ExitSuccess) $ throwIO $ TestFailure out err ec where withDir = withSystemTempDirectory ("stack-integration-" ++ name) data TestFailure = TestFailure L.ByteString L.ByteString ExitCode deriving Typeable instance Show TestFailure where show (TestFailure out err ec) = concat [ "Exited with " ++ show ec , "\n\nstdout:\n" , toStr out , "\n\nstderr:\n" , toStr err ] where toStr = TL.unpack . TL.decodeUtf8With lenientDecode instance Exception TestFailure copyTree :: (FilePath -> Bool) -> FilePath -> FilePath -> IO () copyTree toCopy src dst = runResourceT (sourceDirectoryDeep False src `connect` CL.mapM_ go) `catch` \(_ :: IOException) -> return () where go srcfp = when (toCopy srcfp) $ liftIO $ do Just suffix <- return $ stripPrefix src srcfp let dstfp = dst ++ "/" ++ suffix createDirectoryIfMissing True $ takeDirectory dstfp createSymbolicLink srcfp dstfp `catch` \(_ :: IOException) -> copyFile srcfp dstfp -- for Windows toCopyRoot :: FilePath -> Bool toCopyRoot srcfp = any (`isSuffixOf` srcfp) -- FIXME command line parameters to control how many of these get -- copied, trade-off of runtime/bandwidth vs isolation of tests [ ".tar" , ".xz" -- , ".gz" , ".7z.exe" , "00-index.cache" ] stack-1.9.3.1/test/integration/lib/StackTest.hs0000644000000000000000000001645113455617610017506 0ustar0000000000000000module StackTest where import Control.Monad import Control.Monad.IO.Class import Control.Monad.Trans.Reader import Control.Concurrent import Control.Exception import System.Environment import System.Directory import System.IO import System.IO.Error import System.Process import System.Exit import System.Info (arch, os) run' :: FilePath -> [String] -> IO ExitCode run' cmd args = do logInfo $ "Running: " ++ cmd ++ " " ++ unwords (map showProcessArgDebug args) (Nothing, Nothing, Nothing, ph) <- createProcess (proc cmd args) waitForProcess ph run :: FilePath -> [String] -> IO () run cmd args = do ec <- run' cmd args unless (ec == ExitSuccess) $ error $ "Exited with exit code: " ++ show ec stackExe :: IO String stackExe = getEnv "STACK_EXE" stack' :: [String] -> IO ExitCode stack' args = do stackEnv <- stackExe run' stackEnv args stack :: [String] -> IO () stack args = do ec <- stack' args unless (ec == ExitSuccess) $ error $ "Exited with exit code: " ++ show ec stackErr :: [String] -> IO () stackErr args = do ec <- stack' args when (ec == ExitSuccess) $ error "stack was supposed to fail, but didn't" type Repl = ReaderT ReplConnection IO data ReplConnection = ReplConnection { replStdin :: Handle , replStdout :: Handle } nextPrompt :: Repl () nextPrompt = do (ReplConnection _ inputHandle) <- ask c <- liftIO $ hGetChar inputHandle if c == '>' then do _ <- liftIO $ hGetChar inputHandle return () else nextPrompt replCommand :: String -> Repl () replCommand cmd = do (ReplConnection input _) <- ask liftIO $ hPutStrLn input cmd replGetLine :: Repl String replGetLine = fmap replStdout ask >>= liftIO . hGetLine replGetChar :: Repl Char replGetChar = fmap replStdout ask >>= liftIO . hGetChar runRepl :: FilePath -> [String] -> ReaderT ReplConnection IO () -> IO ExitCode runRepl cmd args actions = do logInfo $ "Running: " ++ cmd ++ " " ++ unwords (map showProcessArgDebug args) (Just rStdin, Just rStdout, Just rStderr, ph) <- createProcess (proc cmd args) { std_in = CreatePipe , std_out = CreatePipe , std_err = CreatePipe } hSetBuffering rStdin NoBuffering hSetBuffering rStdout NoBuffering hSetBuffering rStderr NoBuffering _ <- forkIO $ withFile "/tmp/stderr" WriteMode $ \err -> forever $ catch (hGetChar rStderr >>= hPutChar err) $ \e -> unless (isEOFError e) $ throw e runReaderT (nextPrompt >> actions) (ReplConnection rStdin rStdout) waitForProcess ph repl :: [String] -> Repl () -> IO () repl args action = do stackExe' <- stackExe ec <- runRepl stackExe' ("repl":args) action unless (ec == ExitSuccess) $ return () -- TODO: Understand why the exit code is 1 despite running GHCi tests -- successfully. -- else error $ "Exited with exit code: " ++ show ec stackStderr :: [String] -> IO (ExitCode, String) stackStderr args = do stackExe' <- stackExe logInfo $ "Running: " ++ stackExe' ++ " " ++ unwords (map showProcessArgDebug args) (ec, _, err) <- readProcessWithExitCode stackExe' args "" hPutStr stderr err return (ec, err) -- | Run stack with arguments and apply a check to the resulting -- stderr output if the process succeeded. stackCheckStderr :: [String] -> (String -> IO ()) -> IO () stackCheckStderr args check = do (ec, err) <- stackStderr args if ec /= ExitSuccess then error $ "Exited with exit code: " ++ show ec else check err -- | Same as 'stackCheckStderr', but ensures that the Stack process -- fails. stackErrStderr :: [String] -> (String -> IO ()) -> IO () stackErrStderr args check = do (ec, err) <- stackStderr args if ec == ExitSuccess then error "Stack process succeeded, but it shouldn't" else check err stackStdout :: [String] -> IO (ExitCode, String) stackStdout args = do stackExe' <- stackExe logInfo $ "Running: " ++ stackExe' ++ " " ++ unwords (map showProcessArgDebug args) (ec, out, err) <- readProcessWithExitCode stackExe' args "" putStr out hPutStr stderr err return (ec, out) -- | Run stack with arguments and apply a check to the resulting -- stdout output if the process succeeded. stackCheckStdout :: [String] -> (String -> IO ()) -> IO () stackCheckStdout args check = do (ec, out) <- stackStdout args if ec /= ExitSuccess then error $ "Exited with exit code: " ++ show ec else check out doesNotExist :: FilePath -> IO () doesNotExist fp = do logInfo $ "doesNotExist " ++ fp exists <- doesFileOrDirExist fp case exists of (Right msg) -> error msg (Left _) -> return () doesExist :: FilePath -> IO () doesExist fp = do logInfo $ "doesExist " ++ fp exists <- doesFileOrDirExist fp case exists of (Right _) -> return () (Left _) -> error "No file or directory exists" doesFileOrDirExist :: FilePath -> IO (Either () String) doesFileOrDirExist fp = do isFile <- doesFileExist fp if isFile then return (Right ("File exists: " ++ fp)) else do isDir <- doesDirectoryExist fp if isDir then return (Right ("Directory exists: " ++ fp)) else return (Left ()) copy :: FilePath -> FilePath -> IO () copy src dest = do logInfo ("Copy " ++ show src ++ " to " ++ show dest) System.Directory.copyFile src dest fileContentsMatch :: FilePath -> FilePath -> IO () fileContentsMatch f1 f2 = do doesExist f1 doesExist f2 f1Contents <- readFile f1 f2Contents <- readFile f2 unless (f1Contents == f2Contents) $ error ("contents do not match for " ++ show f1 ++ " " ++ show f2) logInfo :: String -> IO () logInfo = hPutStrLn stderr -- TODO: use stack's process running utilties? (better logging) -- for now just copy+modifying this one from System.Process.Log -- | Show a process arg including speechmarks when necessary. Just for -- debugging purposes, not functionally important. showProcessArgDebug :: String -> String showProcessArgDebug x | any special x = show x | otherwise = x where special '"' = True special ' ' = True special _ = False -- | Extension of executables exeExt :: String exeExt = if isWindows then ".exe" else "" -- | Is the OS Windows? isWindows :: Bool isWindows = os == "mingw32" -- | Is the OS Alpine Linux? getIsAlpine :: IO Bool getIsAlpine = doesFileExist "/etc/alpine-release" -- | Is the architecture ARM? isARM :: Bool isARM = arch == "arm" -- | Is the OS Mac OS X? isMacOSX :: Bool isMacOSX = os == "darwin" -- | To avoid problems with GHC version mismatch when a new LTS major -- version is released, pass this argument to @stack@ when running in -- a global context. The LTS major version here should match that of -- the main @stack.yaml@. -- defaultResolverArg :: String defaultResolverArg = "--resolver=lts-11.22" -- | Remove a file and ignore any warnings about missing files. removeFileIgnore :: FilePath -> IO () removeFileIgnore fp = removeFile fp `catch` \e -> if isDoesNotExistError e then return () else throwIO e -- | Remove a directory tree and ignore any warnings about missing files. removeDirectoryRecursiveIgnore :: FilePath -> IO () removeDirectoryRecursiveIgnore fp = removeDirectoryRecursive fp `catch` \e -> if isDoesNotExistError e then return () else throwIO e stack-1.9.3.1/LICENSE0000644000000000000000000000273113455666157012210 0ustar0000000000000000Copyright (c) 2015-2018, Stack contributors All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. * Neither the name of stack nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL STACK CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. stack-1.9.3.1/Setup.hs0000644000000000000000000000575013312026775012627 0ustar0000000000000000{-# OPTIONS_GHC -fno-warn-warnings-deprecations #-} module Main (main) where import Data.List ( nub, sortBy ) import Data.Ord ( comparing ) import Distribution.Package ( PackageId, InstalledPackageId, packageVersion, packageName ) import Distribution.PackageDescription ( PackageDescription(), Executable(..) ) import Distribution.InstalledPackageInfo (sourcePackageId, installedPackageId) import Distribution.Simple ( defaultMainWithHooks, UserHooks(..), simpleUserHooks ) import Distribution.Simple.Utils ( rewriteFile, createDirectoryIfMissingVerbose ) import Distribution.Simple.BuildPaths ( autogenModulesDir ) import Distribution.Simple.PackageIndex (allPackages, dependencyClosure) import Distribution.Simple.Setup ( BuildFlags(buildVerbosity), fromFlag ) import Distribution.Simple.LocalBuildInfo ( installedPkgs, withLibLBI, withExeLBI, LocalBuildInfo(), ComponentLocalBuildInfo(componentPackageDeps) ) import Distribution.Types.PackageName (PackageName, unPackageName) import Distribution.Types.UnqualComponentName (unUnqualComponentName) import Distribution.Verbosity ( Verbosity ) import Distribution.Version ( showVersion ) import System.FilePath ( () ) main :: IO () main = defaultMainWithHooks simpleUserHooks { buildHook = \pkg lbi hooks flags -> do generateBuildModule (fromFlag (buildVerbosity flags)) pkg lbi buildHook simpleUserHooks pkg lbi hooks flags } generateBuildModule :: Verbosity -> PackageDescription -> LocalBuildInfo -> IO () generateBuildModule verbosity pkg lbi = do let dir = autogenModulesDir lbi createDirectoryIfMissingVerbose verbosity True dir withLibLBI pkg lbi $ \_ libcfg -> do withExeLBI pkg lbi $ \exe clbi -> rewriteFile (dir "Build_" ++ exeName' exe ++ ".hs") $ unlines [ "module Build_" ++ exeName' exe ++ " where" , "" , "deps :: [String]" , "deps = " ++ (show $ formatdeps (transDeps libcfg clbi)) ] where exeName' = unUnqualComponentName . exeName formatdeps = map formatone . sortBy (comparing unPackageName') formatone p = unPackageName' p ++ "-" ++ showVersion (packageVersion p) unPackageName' = unPackageName . packageName transDeps xs ys = either (map sourcePackageId . allPackages) handleDepClosureFailure $ dependencyClosure allInstPkgsIdx availInstPkgIds where allInstPkgsIdx = installedPkgs lbi allInstPkgIds = map installedPackageId $ allPackages allInstPkgsIdx -- instPkgIds includes `stack-X.X.X`, which is not a dependency hence is missing from allInstPkgsIdx. Filter that out. availInstPkgIds = filter (`elem` allInstPkgIds) $ testDeps xs ys handleDepClosureFailure unsatisfied = error $ "Computation of transitive dependencies failed." ++ if null unsatisfied then "" else " Unresolved dependencies: " ++ show unsatisfied testDeps :: ComponentLocalBuildInfo -> ComponentLocalBuildInfo -> [InstalledPackageId] testDeps xs ys = map fst $ nub $ componentPackageDeps xs ++ componentPackageDeps ys stack-1.9.3.1/stack.cabal0000644000000000000000000003435113455712745013272 0ustar0000000000000000cabal-version: 1.24 -- This file has been generated from package.yaml by hpack version 0.31.2. -- -- see: https://github.com/sol/hpack -- -- hash: 4660c8af471b9e6d591f3414122079e0f1d8ee984995ed25cf46c4b01ed78b66 name: stack version: 1.9.3.1 synopsis: The Haskell Tool Stack description: Please see the README.md for usage information, and the wiki on Github for more details. Also, note that the API for the library is not currently stable, and may change significantly, even between minor releases. It is currently only intended for use by the executable. category: Development homepage: http://haskellstack.org bug-reports: https://github.com/commercialhaskell/stack/issues author: Commercial Haskell SIG maintainer: manny@fpcomplete.com license: BSD3 license-file: LICENSE build-type: Custom extra-source-files: CONTRIBUTING.md ChangeLog.md README.md doc/architecture.md doc/build_command.md doc/ChangeLog.md doc/CONTRIBUTING.md doc/coverage.md doc/custom_snapshot.md doc/dependency_visualization.md doc/docker_integration.md doc/faq.md doc/ghci.md doc/ghcjs.md doc/GUIDE.md doc/install_and_upgrade.md doc/nix_integration.md doc/nonstandard_project_init.md doc/README.md doc/shell_autocompletion.md doc/SIGNING_KEY.md doc/stack_yaml_vs_cabal_package_file.md doc/travis_ci.md doc/yaml_configuration.md src/setup-shim/StackSetupShim.hs stack.yaml test/package-dump/ghc-7.10.txt test/package-dump/ghc-7.8.4-osx.txt test/package-dump/ghc-7.8.txt test/package-dump/ghc-head.txt src/test/Stack/Untar/test1.tar.gz src/test/Stack/Untar/test2.tar.gz source-repository head type: git location: https://github.com/commercialhaskell/stack custom-setup setup-depends: Cabal , base >=4.10 && <5 , filepath flag disable-git-info description: Disable compile-time inclusion of current git info in stack manual: True default: False flag hide-dependency-versions description: Hides dependency versions from "stack --version", used only by building with stack.yaml manual: True default: False flag integration-tests description: Run the integration test suite manual: True default: False flag static description: Pass -static/-pthread to ghc when linking the stack binary. manual: True default: False flag supported-build description: If false, causes "stack --version" to issue a warning about the build being unsupported. True only if building with stack.yaml manual: True default: False library exposed-modules: Control.Concurrent.Execute Data.Aeson.Extended Data.Attoparsec.Args Data.Attoparsec.Combinators Data.Attoparsec.Interpreter Data.IORef.RunOnce Data.Monoid.Map Data.Store.VersionTagged Network.HTTP.Download Network.HTTP.Download.Verified Network.HTTP.StackClient Options.Applicative.Args Options.Applicative.Builder.Extra Options.Applicative.Complicated Path.CheckInstall Path.Extra Path.Find Paths_stack Stack.Build Stack.Build.Cache Stack.Build.ConstructPlan Stack.Build.Execute Stack.Build.Haddock Stack.Build.Installed Stack.Build.Source Stack.Build.Target Stack.BuildPlan Stack.Clean Stack.Config Stack.Config.Build Stack.Config.Urls Stack.Config.Docker Stack.Config.Nix Stack.ConfigCmd Stack.Constants Stack.Constants.Config Stack.Coverage Stack.DefaultColorWhen Stack.Docker Stack.Docker.GlobalDB Stack.Dot Stack.Fetch Stack.FileWatch Stack.GhcPkg Stack.Ghci Stack.Ghci.Script Stack.Hoogle Stack.IDE Stack.Image Stack.Init Stack.Ls Stack.New Stack.Nix Stack.Options.BenchParser Stack.Options.BuildMonoidParser Stack.Options.BuildParser Stack.Options.CleanParser Stack.Options.ConfigParser Stack.Options.Completion Stack.Options.DockerParser Stack.Options.DotParser Stack.Options.ExecParser Stack.Options.GhcBuildParser Stack.Options.GhciParser Stack.Options.GhcVariantParser Stack.Options.GlobalParser Stack.Options.HaddockParser Stack.Options.HpcReportParser Stack.Options.LogLevelParser Stack.Options.NewParser Stack.Options.NixParser Stack.Options.PackageParser Stack.Options.ResolverParser Stack.Options.ScriptParser Stack.Options.SDistParser Stack.Options.SolverParser Stack.Options.TestParser Stack.Options.Utils Stack.Package Stack.PackageDump Stack.PackageIndex Stack.PackageLocation Stack.Path Stack.Prelude Stack.PrettyPrint Stack.Runners Stack.Script Stack.SDist Stack.Setup Stack.Setup.Installed Stack.SetupCmd Stack.Sig Stack.Sig.GPG Stack.Sig.Sign Stack.Snapshot Stack.Solver Stack.StaticBytes Stack.Types.Build Stack.Types.BuildPlan Stack.Types.CompilerBuild Stack.Types.Urls Stack.Types.Compiler Stack.Types.Config Stack.Types.Config.Build Stack.Types.Docker Stack.Types.FlagName Stack.Types.GhcPkgId Stack.Types.Image Stack.Types.NamedComponent Stack.Types.Nix Stack.Types.Package Stack.Types.PackageDump Stack.Types.PackageIdentifier Stack.Types.PackageIndex Stack.Types.PackageName Stack.Types.Resolver Stack.Types.Runner Stack.Types.Sig Stack.Types.TemplateName Stack.Types.Version Stack.Types.VersionIntervals Stack.Upgrade Stack.Upload Text.PrettyPrint.Leijen.Extended System.Process.PagerEditor System.Terminal other-modules: Hackage.Security.Client.Repository.HttpLib.HttpClient hs-source-dirs: src/ ghc-options: -Wall -fwarn-tabs -fwarn-incomplete-uni-patterns -fwarn-incomplete-record-updates -optP-Wno-nonportable-include-path -fwarn-identities build-depends: Cabal , aeson , annotated-wl-pprint , ansi-terminal , async , attoparsec , base >=4.10 && <5 , base64-bytestring , bytestring , conduit , conduit-extra , containers , cryptonite , cryptonite-conduit , deepseq , directory , echo , exceptions , extra , file-embed , filelock , filepath , fsnotify , generic-deriving , hackage-security , hashable , hpack , hpc , http-client , http-client-tls , http-conduit , http-types , memory , microlens , mintty , monad-logger , mono-traversable , mtl , mustache , neat-interpolation , network-uri , open-browser , optparse-applicative , path , path-io , persistent , persistent-sqlite , persistent-template , pretty , primitive , process , project-template , regex-applicative-text , resourcet , retry , rio , semigroups , split , stm , store , store-core , streaming-commons , tar , template-haskell , temporary , text , text-metrics , th-reify-many , time , tls , transformers , typed-process , unicode-transforms , unix-compat , unliftio , unordered-containers , vector , yaml , zip-archive , zlib if os(windows) cpp-options: -DWINDOWS build-depends: Win32 else build-tools: hsc2hs build-depends: bindings-uname , unix if os(windows) hs-source-dirs: src/windows/ else hs-source-dirs: src/unix/ default-language: Haskell2010 autogen-modules: Paths_stack executable stack main-is: Main.hs other-modules: Build_stack Paths_stack hs-source-dirs: src/main ghc-options: -Wall -fwarn-tabs -fwarn-incomplete-uni-patterns -fwarn-incomplete-record-updates -optP-Wno-nonportable-include-path -threaded -rtsopts build-depends: Cabal , aeson , annotated-wl-pprint , ansi-terminal , async , attoparsec , base >=4.10 && <5 , base64-bytestring , bytestring , conduit , conduit-extra , containers , cryptonite , cryptonite-conduit , deepseq , directory , echo , exceptions , extra , file-embed , filelock , filepath , fsnotify , generic-deriving , hackage-security , hashable , hpack , hpc , http-client , http-client-tls , http-conduit , http-types , memory , microlens , mintty , monad-logger , mono-traversable , mtl , mustache , neat-interpolation , network-uri , open-browser , optparse-applicative , path , path-io , persistent , persistent-sqlite , persistent-template , pretty , primitive , process , project-template , regex-applicative-text , resourcet , retry , rio , semigroups , split , stack , stm , store , store-core , streaming-commons , tar , template-haskell , temporary , text , text-metrics , th-reify-many , time , tls , transformers , typed-process , unicode-transforms , unix-compat , unliftio , unordered-containers , vector , yaml , zip-archive , zlib if os(windows) cpp-options: -DWINDOWS build-depends: Win32 else build-tools: hsc2hs build-depends: bindings-uname , unix if flag(static) ld-options: -static -pthread if !(flag(disable-git-info)) cpp-options: -DUSE_GIT_INFO build-depends: githash , optparse-simple if flag(hide-dependency-versions) cpp-options: -DHIDE_DEP_VERSIONS if flag(supported-build) cpp-options: -DSUPPORTED_BUILD default-language: Haskell2010 autogen-modules: Build_stack, Paths_stack test-suite stack-integration-test type: exitcode-stdio-1.0 main-is: IntegrationSpec.hs other-modules: StackTest Paths_stack hs-source-dirs: test/integration test/integration/lib ghc-options: -Wall -fwarn-tabs -fwarn-incomplete-uni-patterns -fwarn-incomplete-record-updates -optP-Wno-nonportable-include-path -threaded -rtsopts -with-rtsopts=-N build-depends: Cabal , aeson , annotated-wl-pprint , ansi-terminal , async , attoparsec , base >=4.10 && <5 , base64-bytestring , bytestring , conduit , conduit-extra , containers , cryptonite , cryptonite-conduit , deepseq , directory , echo , exceptions , extra , file-embed , filelock , filepath , fsnotify , generic-deriving , hackage-security , hashable , hpack , hpc , hspec , http-client , http-client-tls , http-conduit , http-types , memory , microlens , mintty , monad-logger , mono-traversable , mtl , mustache , neat-interpolation , network-uri , open-browser , optparse-applicative , path , path-io , persistent , persistent-sqlite , persistent-template , pretty , primitive , process , project-template , regex-applicative-text , resourcet , retry , rio , semigroups , split , stm , store , store-core , streaming-commons , tar , template-haskell , temporary , text , text-metrics , th-reify-many , time , tls , transformers , typed-process , unicode-transforms , unix-compat , unliftio , unordered-containers , vector , yaml , zip-archive , zlib if os(windows) cpp-options: -DWINDOWS build-depends: Win32 else build-tools: hsc2hs build-depends: bindings-uname , unix if !(flag(integration-tests)) buildable: False default-language: Haskell2010 test-suite stack-test type: exitcode-stdio-1.0 main-is: Test.hs other-modules: Network.HTTP.Download.VerifiedSpec Spec Stack.ArgsSpec Stack.Build.ExecuteSpec Stack.Build.TargetSpec Stack.ConfigSpec Stack.DotSpec Stack.Ghci.PortableFakePaths Stack.Ghci.ScriptSpec Stack.GhciSpec Stack.NixSpec Stack.PackageDumpSpec Stack.SolverSpec Stack.StaticBytesSpec Stack.StoreSpec Stack.Types.BuildPlanSpec Stack.Types.TemplateNameSpec Stack.Untar.UntarSpec Paths_stack hs-source-dirs: src/test ghc-options: -Wall -fwarn-tabs -fwarn-incomplete-uni-patterns -fwarn-incomplete-record-updates -optP-Wno-nonportable-include-path -threaded build-depends: Cabal , QuickCheck , aeson , annotated-wl-pprint , ansi-terminal , async , attoparsec , base >=4.10 && <5 , base64-bytestring , bytestring , conduit , conduit-extra , containers , cryptonite , cryptonite-conduit , deepseq , directory , echo , exceptions , extra , file-embed , filelock , filepath , fsnotify , generic-deriving , hackage-security , hashable , hpack , hpc , hspec , http-client , http-client-tls , http-conduit , http-types , memory , microlens , mintty , monad-logger , mono-traversable , mtl , mustache , neat-interpolation , network-uri , open-browser , optparse-applicative , path , path-io , persistent , persistent-sqlite , persistent-template , pretty , primitive , process , project-template , regex-applicative-text , resourcet , retry , rio , semigroups , smallcheck , split , stack , stm , store , store-core , streaming-commons , tar , template-haskell , temporary , text , text-metrics , th-reify-many , time , tls , transformers , typed-process , unicode-transforms , unix-compat , unliftio , unordered-containers , vector , yaml , zip-archive , zlib if os(windows) cpp-options: -DWINDOWS build-depends: Win32 else build-tools: hsc2hs build-depends: bindings-uname , unix default-language: Haskell2010 stack-1.9.3.1/CONTRIBUTING.md0000644000000000000000000001422613455617610013424 0ustar0000000000000000# Contributors Guide ## Bug Reports Please [open an issue](https://github.com/commercialhaskell/stack/issues/new) and use the provided template to include all necessary details. The more detailed your report, the faster it can be resolved and will ensure it is resolved in the right way. Once your bug has been resolved, the responsible person will tag the issue as _Needs confirmation_ and assign the issue back to you. Once you have tested and confirmed that the issue is resolved, close the issue. If you are not a member of the project, you will be asked for confirmation and we will close it. ## Documentation If you would like to help with documentation, please note that for most cases the Wiki has been deprecated in favor of markdown files placed in a new `/doc` subdirectory of the repository itself. Please submit a [pull request](https://help.github.com/articles/using-pull-requests/) with your changes/additions based off the [the stable branch](https://github.com/commercialhaskell/stack/tree/stable). The documentation is rendered on [haskellstack.org](http://haskellstack.org) by readthedocs.org using Sphinx and CommonMark. Since links and formatting vary from GFM, please check the documentation there before submitting a PR to fix those. If your changes move or rename files, or subsume Wiki content, please continue to leave a file/page in the old location temporarily, in addition to the new location. This will allow users time to update any shared links to the old location. Please also update any links in other files, or on the Wiki, to point to the new file location. ## Code If you would like to contribute code to fix a bug, add a new feature, or otherwise improve `stack`, pull requests are most welcome. It's a good idea to [submit an issue](https://github.com/commercialhaskell/stack/issues/new) to discuss the change before plowing into writing code. If you'd like to help out but aren't sure what to work on, look for issues with the [awaiting pull request](https://github.com/commercialhaskell/stack/issues?q=is%3Aopen+is%3Aissue+label%3A%22awaiting+pull+request%22) label. Issues that are suitable for newcomers to the codebase have the [newcomer friendly](https://github.com/commercialhaskell/stack/issues?q=is%3Aopen+is%3Aissue+label%3A%22awaiting+pull+request%22+label%3a%22newcomer+friendly%22) label. Best to post a comment to the issue before you start work, in case anyone has already started. Please include a [ChangeLog](https://github.com/commercialhaskell/stack/blob/master/ChangeLog.md) entry and [documentation](https://github.com/commercialhaskell/stack/tree/master/doc/) updates with your pull request. ## Code Quality The Stack projects uses [HLint](https://github.com/ndmitchell/hlint) as a code quality tool. Note that stack contributors need not dogmatically follow the suggested hints but are encouraged to debate their usefulness. If you find a hint is not useful and detracts from readability, consider marking it in the [configuration file](https://github.com/commercialhaskell/stack/blob/master/.hlint.yaml) to be ignored. Please refer to the [HLint manual](https://github.com/ndmitchell/hlint#readme) for configuration syntax. Quoting [@mgsloan](https://github.com/commercialhaskell/stack/pulls?utf8=%E2%9C%93&q=is%3Apr%20author%3Amgsloan): > We are optimizing for code clarity, not code concision or what HLint thinks. You can install HLint with stack. You might want to install it in the global project in case you run into dependency conflicts. HLint can report hints in your favourite text editor. Refer to the HLint repository for more details. To install: ``` stack install hlint ``` Once installed, you can check your changes with: ``` $ ./etc/scripts/hlint.sh ``` ## Testing The Stack code has both unit tests and integration tests. Integration tests can be found in the [test/integration](https://github.com/commercialhaskell/stack/tree/master/test/integration) folder and unit tests, in the [src/test](https://github.com/commercialhaskell/stack/tree/master/src/test) folder. Tests are written using the [Hspec](https://hspec.github.io/) framework. In order to run the full test suite, you can simply do: ```bash $ stack test ``` The `--file-watch` is a very useful option to get quick feedback. However, running the entire test suite after each file change will slow you down. You'll need to specify which test suite (unit test or integration) and pass arguments to specify which module you'd specifically like to run to get quick feedback. A description of this follows below. ### Working with Unit Tests If you would like to run the unit tests on their own, you can: ```bash $ stack test stack:stack-test ``` Running an individual module works like this: ```bash $ stack test stack:stack-test --ta "-m " ``` Where `` is the name of the module without `Spec.hs`. You may also load tests into GHCi and run them with: ```bash $ stack ghci stack:stack-test --only-main # GHCi starting up output ... > :main -m "" ``` Where again, `` is the name of the module without `Spec.hs`. ### Working with Integration Tests Running the integration tests is a little involved, you'll need to: ```bash $ stack test stack:stack-integration-test --flag stack:integration-tests ``` Running an individual module works like this: ```bash $ stack test stack:stack-integration-test --flag stack:integration-tests --ta "-m " ``` Where `` is the name of the folder listed in the [test/integration/tests/](https://github.com/commercialhaskell/stack/tree/master/test/integration/tests) folder. You may also achieve this through GHCi with: ```bash $ stack ghci stack:stack-integration-test # GHCi starting up output ... > :main -m "" ``` Where again, `` is the name of the folder listed in the [test/integration/tests/](https://github.com/commercialhaskell/stack/tree/master/test/integration/tests) folder. ## Slack channel If you're making deep changes and real-time communcation with the Stack team would be helpful, we have a `#stack-collaborators` Slack channel. Please contact [@borsboom](https://github.com/borsboom) (manny@fpcomplete.com) or [@snoyberg](https://github.com/snoyberg) (michael@fpcomplete.com) for an invite. stack-1.9.3.1/ChangeLog.md0000644000000000000000000032467113455702176013356 0ustar0000000000000000# Changelog ## v1.9.3.1 Hackage-only release with no user facing changes (added compatibility with `rio-0.1.9.2`). ## v1.9.3 Bug fixes: * Stack can now be compiled again inside a directory that does not contain a `.git` directory, see [#4364](https://github.com/commercialhaskell/stack/issues/4364#issuecomment-431600841) * Handle a change in GHC's hi-dump format around `addDependentFile`, which now includes a hash. See [yesodweb/yesod#1551](https://github.com/yesodweb/yesod/issues/1551) * Allow variables to appear in template file names. ## v1.9.1.1 Hackage-only release with no user facing changes. * Stack can now be compiled again inside a directory that does not contain a `.git` directory, see [#4364](https://github.com/commercialhaskell/stack/issues/4364#issuecomment-431600841) ## v1.9.1 Release notes: * Statically linked Linux bindists are back again, thanks to [@nh2](https://github.com/nh2). * We will be deleting the Ubuntu, Debian, CentOS, Fedora, and Arch package repos from `download.fpcomplete.com` soon. These have been deprecated for over a year and have not received new releases, but were left in place for compatibility with older scripts. Major changes: * Upgrade to Cabal 2.4 * Note that, in this process, the behavior of file globbing has been modified to match that of Cabal. In particular, this means that for Cabal spec versions less than 2.4, `*.txt` will match `foo.txt`, but not `foo.2.txt`. * `GHCJS` support is being downgraded to 'experimental'. A warning notifying the user of the experimental status of `GHCJS` will be displayed. Behavior changes: * `ghc-options` from `stack.yaml` are now appended to `ghc-options` from `config.yaml`, whereas before they would be replaced. * `stack build` will now announce when sublibraries of a package are being build, in the same way executables, tests, benchmarks and libraries are announced * `stack sdist` will now announce the destination of the generated tarball, regardless of whether or not it passed the sanity checks * The `--upgrade-cabal` option to `stack setup` has been deprecated. This feature no longer works with GHC 8.2 and later. Furthermore, the reason for this flag originally being implemented was drastically lessened once Stack started using the snapshot's `Cabal` library for custom setups. See: [#4070](https://github.com/commercialhaskell/stack/issues/4070). * With the new namespaced template feature, `stack templates` is no longer able to meaningfully display a list of all templates available. Instead, the command will download and display a [help file](https://github.com/commercialhaskell/stack-templates/blob/master/STACK_HELP.md) with more information on how to discover templates. See: [#4039](https://github.com/commercialhaskell/stack/issues/4039) * Build tools are now handled in a similar way to `cabal-install`. In particular, for legacy `build-tools` fields, we use a hard-coded list of build tools in place of looking up build tool packages in a tool map. This both brings Stack's behavior closer into line with `cabal-install`, avoids some bugs, and opens up some possible optimizations/laziness. See: [#4125](https://github.com/commercialhaskell/stack/issues/4125). * Mustache templating is not applied to large files (over 50kb) to avoid performance degredation. See: [#4133](https://github.com/commercialhaskell/stack/issues/4133). * `stack upload` signs the package by default, as documented. `--no-signature` turns the signing off. [#3739](https://github.com/commercialhaskell/stack/issues/3739) * In case there is a network connectivity issue while trying to download a template, stack will check whether that template had been downloaded before. In that case, the cached version will be used. See [#3850](https://github.com/commercialhaskell/stack/issues/3850). Other enhancements: * On Windows before Windows 10, --color=never is the default on terminals that can support ANSI color codes in output only by emulation * On Windows, recognise a 'mintty' (false) terminal as a terminal, by default * `stack build` issues a warning when `base` is explicitly listed in `extra-deps` of `stack.yaml` * `stack build` suggests trying another GHC version should the build plan end up requiring unattainable `base` version. * A new sub command `run` has been introduced to build and run a specified executable similar to `cabal run`. If no executable is provided as the first argument, it defaults to the first available executable in the project. * `stack build` missing dependency suggestions (on failure to construct a valid build plan because of missing deps) are now printed with their latest cabal file revision hash. See [#4068](https://github.com/commercialhaskell/stack/pull/4068). * Added new `--tar-dir` option to `stack sdist`, that allows to copy the resulting tarball to the specified directory. * Introduced the `--interleaved-output` command line option and `build.interleaved-output` config value which causes multiple concurrent builds to dump to stderr at the same time with a `packagename> ` prefix. See [#3225](https://github.com/commercialhaskell/stack/issues/3225). * The default retry strategy has changed to exponential backoff. This should help with [#3510](https://github.com/commercialhaskell/stack/issues/3510). * `stack new` now allows template names of the form `username/foo` to download from a user other than `commercialstack` on Github, and can be prefixed with the service `github:`, `gitlab:`, or `bitbucket:`. [#4039](https://github.com/commercialhaskell/stack/issues/4039) * Switch to `githash` to include some unmerged bugfixes in `gitrev` Suggestion to add `'allow-newer': true` now shows path to user config file where this flag should be put into [#3685](https://github.com/commercialhaskell/stack/issues/3685) * `stack ghci` now asks which main target to load before doing the build, rather than after * Bump to hpack 0.29.0 * With GHC 8.4 and later, Haddock is given the `--quickjump` flag. * It is possible to specify the Hackage base URL to upload packages to, instead of the default of `https://hackage.haskell.org/`, by using `hackage-base-url` configuration option. * When using Nix, if a specific minor version of GHC is not requested, the latest minor version in the given major branch will be used automatically. Bug fixes: * `stack ghci` now does not invalidate `.o` files on repeated runs, meaning any modules compiled with `-fobject-code` will be cached between ghci runs. See [#4038](https://github.com/commercialhaskell/stack/pull/4038). * `~/.stack/config.yaml` and `stack.yaml` terminating by newline * The previous released caused a regression where some `stderr` from the `ghc-pkg` command showed up in the terminal. This output is now silenced. * A regression in recompilation checking introduced in v1.7.1 has been fixed. See [#4001](https://github.com/commercialhaskell/stack/issues/4001) * `stack ghci` on a package with internal libraries was erroneously looking for a wrong package corresponding to the internal library and failing to load any module. This has been fixed now and changes to the code in the library and the sublibrary are properly tracked. See [#3926](https://github.com/commercialhaskell/stack/issues/3926). * For packages with internal libraries not depended upon, `stack build` used to fail the build process since the internal library was not built but it was tried to be registered. This is now fixed by always building internal libraries. See [#3996](https://github.com/commercialhaskell/stack/issues/3996). * `--no-nix` was not respected under NixOS * Fix a regression which might use a lot of RAM. See [#4027](https://github.com/commercialhaskell/stack/issues/4027). * Order of commandline arguments does not matter anymore. See [#3959](https://github.com/commercialhaskell/stack/issues/3959) * When prompting users about saving their Hackage credentials on upload, flush to stdout before waiting for the response so the prompt actually displays. Also fixes a similar issue with ghci target selection prompt. * If `cabal` is not on PATH, running `stack solver` now prompts the user to run `stack install cabal-install` * `stack build` now succeeds in building packages which contain sublibraries which are dependencies of executables, tests or benchmarks but not of the main library. See [#3787](https://github.com/commercialhaskell/stack/issues/3787). * Sublibraries are now properly considered for coverage reports when the test suite depends on the internal library. Before, stack was erroring when trying to generate the coverage report, see [#4105](https://github.com/commercialhaskell/stack/issues/4105). * Sublibraries are now added to the precompiled cache and recovered from there when the snapshot gets updated. Previously, updating the snapshot when there was a package with a sublibrary in the snapshot resulted in broken builds. This is now fixed, see [#4071](https://github.com/commercialhaskell/stack/issues/4071). * [#4114](https://github.com/commercialhaskell/stack/issues/4114) Stack pretty prints error messages with proper `error` logging level instead of `warning` now. This also fixes self-executing scripts not piping plan construction errors from runhaskell to terminal (issue [#3942](https://github.com/commercialhaskell/stack/issues/3942)). * Fix invalid "While building Setup.hs" when Cabal calls fail. See: [#3934](https://github.com/commercialhaskell/stack/issues/3934) * `stack upload` signs the package by default, as documented. `--no-signature` turns the signing off. [#3739](https://github.com/commercialhaskell/stack/issues/3739) ## v1.7.1 Release notes: * aarch64 (64-bit ARM) bindists are now available for the first time. * Statically linked Linux bindists are no longer available, due to difficulty with GHC 8.2.2 on Alpine Linux. * 32-bit Linux GMP4 bindists for CentOS 6 are no longer available, since GHC 8.2.2 is no longer being built for that platform. Major changes: * Upgrade from Cabal 2.0 to Cabal 2.2 Behavior changes: * `stack setup` no longer uses different GHC configure options on Linux distributions that use GCC with PIE enabled by default. GHC detects this itself since ghc-8.0.2, and Stack's attempted workaround for older versions caused more problems than it solved. * `stack new` no longer initializes a project if the project template contains a stack.yaml file. Other enhancements: * A new sub command `ls` has been introduced to stack to view local and remote snapshots present in the system. Use `stack ls snapshots --help` to get more details about it. * `list-dependencies` has been deprecated. The functionality has to accessed through the new `ls dependencies` interface. See [#3669](https://github.com/commercialhaskell/stack/issues/3669) for details. * Specify User-Agent HTTP request header on every HTTP request. See [#3628](https://github.com/commercialhaskell/stack/issues/3628) for details. * `stack setup` looks for GHC bindists and installations by any OS key that is compatible (rather than only checking a single one). This is relevant on Linux where different distributions may have different combinations of libtinfo 5/6, ncurses 5/6, and gmp 4/5, and will allow simpifying the setup-info metadata YAML for future GHC releases. * The build progress bar reports names of packages currently building. * `stack setup --verbose` causes verbose output of GHC configure process. See [#3716](https://github.com/commercialhaskell/stack/issues/3716) * Improve the error message when an `extra-dep` from a path or git reference can't be found See [#3808](https://github.com/commercialhaskell/stack/pull/3808) * Nix integration is now disabled on windows even if explicitly enabled, since it isn't supported. See [#3600](https://github.com/commercialhaskell/stack/issues/3600) * `stack build` now supports a new flag `--keep-tmp-files` to retain intermediate files and directories for the purpose of debugging. It is best used with ghc's equivalent flag, i.e. `stack build --keep-tmp-files --ghc-options=-keep-tmp-files`. See [#3857](https://github.com/commercialhaskell/stack/issues/3857) * Improved error messages for snapshot parse exceptions * `stack unpack` now supports a `--to /target/directory` option to specify where to unpack the package into * `stack hoogle` now supports a new flag `--server` that launches local Hoogle server on port 8080. See [#2310](https://github.com/commercialhaskell/stack/issues/2310) Bug fixes: * The script interpreter's implicit file arguments are now passed before other arguments. See [#3658](https://github.com/commercialhaskell/stack/issues/3658). In particular, this makes it possible to pass `-- +RTS ... -RTS` to specify RTS arguments used when running the script. * Don't ignore the template `year` parameter in config files, and clarify the surrounding documentation. See [#2275](https://github.com/commercialhaskell/stack/issues/2275). * Benchmarks used to be run concurrently with other benchmarks and build steps. This is non-ideal because CPU usage of other processes may interfere with benchmarks. It also prevented benchmark output from being displayed by default. This is now fixed. See [#3663](https://github.com/commercialhaskell/stack/issues/3663). * `stack ghci` now allows loading multiple packages with the same module name, as long as they have the same filepath. See [#3776](https://github.com/commercialhaskell/stack/pull/3776). * `stack ghci` no longer always adds a dependency on `base`. It is now only added when there are no local targets. This allows it to be to load code that uses replacements for `base`. See [#3589](https://github.com/commercialhaskell/stack/issues/3589#issuecomment) * `stack ghci` now uses correct paths for autogen files with [#3791](https://github.com/commercialhaskell/stack/issues/3791) * When a package contained sublibraries, stack was always recompiling the package. This has been fixed now, no recompilation is being done because of sublibraries. See [#3899](https://github.com/commercialhaskell/stack/issues/3899). * The `get-stack.sh` install script now matches manual instructions when it comes to Debian/Fedora/CentOS install dependencies. * Compile Cabal-simple with gmp when using Nix. See [#2944](https://github.com/commercialhaskell/stack/issues/2944) * `stack ghci` now replaces the stack process with ghci. This improves signal handling behavior. In particular, handling of Ctrl-C. To make this possible, the generated files are now left behind after exit. The paths are based on hashing file contents, and it's stored in the system temporary directory, so this shouldn't result in too much garbage. See [#3821](https://github.com/commercialhaskell/stack/issues/3821). ## v1.6.5 Bug fixes: * Some unnecessary rebuilds when no files were changed are now avoided, by having a separate build cache for each component of a package. See [#3732](https://github.com/commercialhaskell/stack/issues/3732). * Correct the behavior of promoting a package from snapshot to local package. This would get triggered when version bounds conflicted in a snapshot, which could be triggered via Hackage revisions for old packages. This also should allow custom snapshots to define conflicting versions of packages without issue. See [Stackage issue #3185](https://github.com/fpco/stackage/issues/3185). * When promoting packages from snapshot to local, we were occassionally discarding the actual package location content and instead defaulting to pulling the package from the index. We now correctly retain this information. Note that if you were affected by this bug, you will likely need to delete the binary build cache associated with the relevant custom snapshot. See [#3714](https://github.com/commercialhaskell/stack/issues/3714). * `--no-rerun-tests` has been fixed. Previously, after running a test we were forgetting to record the result, which meant that all tests always ran even if they had already passed before. See [#3770](https://github.com/commercialhaskell/stack/pull/3770). * Includes a patched version of `hackage-security` which fixes both some issues around asynchronous exception handling, and moves from directory locking to file locking, making the update mechanism resilient against SIGKILL and machine failure. See [hackage-security #187](https://github.com/haskell/hackage-security/issues/187) and [#3073](https://github.com/commercialhaskell/stack/issues/3073). ## v1.6.3.1 Hackage-only release with no user facing changes (updated to build with newer version of hpack dependency). ## v1.6.3 Enhancements: * In addition to supporting `.tar.gz` and `.zip` files as remote archives, plain `.tar` files are now accepted too. This will additionally help with cases where HTTP servers mistakenly set the transfer encoding to `gzip`. See [#3647](https://github.com/commercialhaskell/stack/issues/3647). * Links to docs.haskellstack.org ignore Stack version patchlevel. * Downloading Docker-compatible `stack` binary ignores Stack version patchlevel. Bug fixes: * For versions of Cabal before 1.24, ensure that the dependencies of non-buildable components are part of the build plan to work around an old Cabal bug. See [#3631](https://github.com/commercialhaskell/stack/issues/3631). * Run the Cabal file checking in the `sdist` command more reliably by allowing the Cabal library to flatten the `GenericPackageDescription` itself. ## v1.6.1.1 Hackage-only release with no user facing changes (updated to build with newer dependency versions). ## v1.6.1 Major changes: * Complete overhaul of how snapshots are defined, the `packages` and `extra-deps` fields, and a number of related items. For full details, please see [the writeup on these changes](https://www.fpcomplete.com/blog/2017/07/stacks-new-extensible-snapshots). [PR #3249](https://github.com/commercialhaskell/stack/pull/3249), see the PR description for a number of related issues. * Upgraded to version 2.0 of the Cabal library. Behavior changes: * The `--install-ghc` flag is now on by default. For example, if you run `stack build` in a directory requiring a GHC that you do not currently have, Stack will automatically download and install that GHC. You can explicitly set `install-ghc: false` or pass the flag `--no-install-ghc` to regain the previous behavior. * `stack ghci` no longer loads modules grouped by package. This is always an improvement for plain ghci - it makes loading faster and less noisy. For intero, this has the side-effect that it will no longer load multiple packages that depend on TH loading relative paths. TH relative paths will still work when loading a single package into intero. See [#3309](https://github.com/commercialhaskell/stack/issues/3309) * Setting GHC options for a package via `ghc-options:` in your `stack.yaml` will promote it to a local package, providing for more consistency with flags and better reproducibility. See: [#849](https://github.com/commercialhaskell/stack/issues/849) * The `package-indices` setting with Hackage no longer works with the `00-index.tar.gz` tarball, but must use the `01-index.tar.gz` file to allow revised packages to be found. * Options passed via `--ghci-options` are now passed to the end of the invocation of ghci, instead of the middle. This allows using `+RTS` without an accompanying `-RTS`. * When auto-detecting `--ghc-build`, `tinfo6` is now preferred over `standard` if both versions of libtinfo are installed * Addition of `stack build --copy-compiler-tool`, to allow tools like intero to be installed globally for a particular compiler. [#2643](https://github.com/commercialhaskell/stack/issues/2643) * Stack will ask before saving hackage credentials to file. This new prompt can be avoided by using the `save-hackage-creds` setting. Please see [#2159](https://github.com/commercialhaskell/stack/issues/2159). * The `GHCRTS` environment variable will no longer be passed through to every program stack runs. Instead, it will only be passed through commands like `exec`, `runghc`, `script`, `ghci`, etc. See [#3444](https://github.com/commercialhaskell/stack/issues/3444). * `ghc-options:` for specific packages will now come after the options specified for all packages / particular sets of packages. See [#3573](https://github.com/commercialhaskell/stack/issues/3573). * The `pvp-bounds` feature is no longer fully functional, due to some issues with the Cabal library's printer. See [#3550](https://github.com/commercialhaskell/stack/issues/3550). Other enhancements: * The `with-hpack` configuration option specifies an Hpack executable to use instead of the Hpack bundled with Stack. Please see [#3179](https://github.com/commercialhaskell/stack/issues/3179). * It's now possible to skip tests and benchmarks using `--skip` flag * `GitSHA1` is now `StaticSHA256` and is implemented using the `StaticSize 64 ByteString` for improved performance. See [#3006](https://github.com/commercialhaskell/stack/issues/3006) * Dependencies via HTTP(S) archives have been generalized to allow local file path archives, as well as to support setting a cryptographic hash (SHA256) of the contents for better reproducibility. * Allow specifying `--git-branch` when upgrading * When running `stack upgrade` from a file which is different from the default executable path (e.g., on POSIX systems, `~/.local/bin/stack`), it will now additionally copy the new executable over the currently running `stack` executable. If permission is denied (such as in `/usr/local/bin/stack`), the user will be prompted to try again using `sudo`. This is intended to assist with the user experience when the `PATH` environment variable has not been properly configured, see [#3232](https://github.com/commercialhaskell/stack/issues/3232). * `stack setup` for ghcjs will now install `alex` and `happy` if they are not present. See [#3109](https://github.com/commercialhaskell/stack/issues/3232). * Added `stack ghci --only-main` flag, to skip loading / importing all but main modules. See the ghci documentation page for further info. * Allow GHC's colored output to show through. GHC colors output starting with version 8.2.1, for older GHC this does nothing. Sometimes GHC's heuristics would work fine even before this change, for example in `stack ghci`, but this override's GHC's heuristics when they're broken by our collecting and processing GHC's output. * Extended the `ghc-options` field to support `$locals`, `$targets`, and `$everything`. See: [#3329](https://github.com/commercialhaskell/stack/issues/3329) * Better error message for case that `stack ghci` file targets are combined with invalid package targets. See: [#3342](https://github.com/commercialhaskell/stack/issues/3342) * For profiling now uses `-fprof-auto -fprof-cafs` instead of the deprecated `-auto-all -caf-all`. See: [#3360](https://github.com/commercialhaskell/stack/issues/3360) * Better descriptions are now available for `stack upgrade --help`. See: [#3070](https://github.com/commercialhaskell/stack/issues/3070) * When using Nix, nix-shell now depends always on gcc to prevent build errors when using the FFI. As ghc depends on gcc anyway, this doesn't increase the dependency footprint. * `--cwd DIR` can now be passed to `stack exec` in order to execute the program in a different directory. See: [#3264](https://github.com/commercialhaskell/stack/issues/3264) * Plan construction will detect if you add an executable-only package as a library dependency, resulting in much clearer error messages. See: [#2195](https://github.com/commercialhaskell/stack/issues/2195). * Addition of `--ghc-options` to `stack script` to pass options directly to GHC. See: [#3454](https://github.com/commercialhaskell/stack/issues/3454) * Add hpack `package.yaml` to build Stack itself * Add `ignore-revision-mismatch` setting. See: [#3520](https://github.com/commercialhaskell/stack/issues/3520). * Log when each individual test suite finishes. See: [#3552](https://github.com/commercialhaskell/stack/issues/3552). * Avoid spurious rebuilds when using `--file-watch` by not watching files for executable, test and benchmark components that aren't a target. See: [#3483](https://github.com/commercialhaskell/stack/issues/3483). * Stack will now try to detect the width of the running terminal (only on POSIX for the moment) and use that to better display output messages. Work is ongoing, so some messages will not be optimal yet. The terminal width can be overridden with the new `--terminal-width` command-line option (this works even on non-POSIX). * Passing non local packages as targets to `stack ghci` will now cause them to be used as `-package` args along with package hiding. * Detect when user changed .cabal file instead of package.yaml. This was implemented upstream in hpack. See [#3383](https://github.com/commercialhaskell/stack/issues/3383). * Automatically run `autoreconf -i` as necessary when a `configure` script is missing. See [#3534](https://github.com/commercialhaskell/stack/issues/3534) * GHC bindists can now be identified by their SHA256 checksum in addition to their SHA1 checksum, allowing for more security in download. * For filesystem setup-info paths, it's no longer assumed that the directory is writable, instead a temp dir is used. See [#3188](https://github.com/commercialhaskell/stack/issues/3188). Bug fixes: * `stack hoogle` correctly generates Hoogle databases. See: [#3362](https://github.com/commercialhaskell/stack/issues/3362) * `stack --docker-help` is now clearer about --docker implying system-ghc: true, rather than both --docker and --no-docker. * `stack haddock` now includes package names for all modules in the Haddock index page. See: [#2886](https://github.com/commercialhaskell/stack/issues/2886) * Fixed an issue where Stack wouldn't detect missing Docker images properly with newer Docker versions. [#3171](https://github.com/commercialhaskell/stack/pull/3171) * Previously, cabal files with just test-suite could cause build to fail ([#2862](https://github.com/commercialhaskell/stack/issues/2862)) * If an invalid snapshot file has been detected (usually due to mismatched hashes), Stack will delete the downloaded file and recommend either retrying or filing an issue upstream. See [#3319](https://github.com/commercialhaskell/stack/issues/3319). * Modified the flag parser within Stack to match the behavior of Cabal's flag parser, which allows multiple sequential dashes. See [#3345](https://github.com/commercialhaskell/stack/issues/3345) * Now clears the hackage index cache if it is older than the downloaded index. Fixes potential issue if stack was interrupted when updating index. See [#3033](https://github.com/commercialhaskell/stack/issues/3033) * The Stack install script now respects the `-d` option. See [#3366](https://github.com/commercialhaskell/stack/pull/3366). * `stack script` can now handle relative paths to source files. See [#3372](https://github.com/commercialhaskell/stack/issues/3372). * Fixes explanation of why a target is needed by the build plan, when the target is an extra dependency from the commandline. See [#3378](https://github.com/commercialhaskell/stack/issues/3378). * Previously, if you delete a yaml file from ~/.stack/build-plan, it would trust the etag and not re-download. Fixed in this version. * Invoking `stack --docker` in parallel now correctly locks the sqlite database. See [#3400](https://github.com/commercialhaskell/stack/issues/3400). * docs.haskellstack.org RTD documentation search is replaced by the mkdocs search. Please see [#3376](https://github.com/commercialhaskell/stack/issues/3376). * `stack clean` now works with nix. See [#3468](https://github.com/commercialhaskell/stack/issues/3376). * `stack build --only-dependencies` no longer builds local project packages that are depended on. See [#3476](https://github.com/commercialhaskell/stack/issues/3476). * Properly handle relative paths stored in the precompiled cache files. See [#3431](https://github.com/commercialhaskell/stack/issues/3431). * In some cases, Cabal does not realize that it needs to reconfigure, and must be told to do so automatically. This would manifest as a "shadowed dependency" error message. We now force a reconfigure whenever a dependency is built, even if the package ID remained the same. See [#2781](https://github.com/commercialhaskell/stack/issues/2781). * When `--pvp-bounds` is enabled for sdist or upload, internal dependencies could cause errors when uploaded to hackage. This is fixed, see [#3290](https://github.com/commercialhaskell/stack/issues/3290) * Fixes a bug where nonexistent hackage versions would cause stack to suggest the same package name, without giving version info. See [#3562](https://github.com/commercialhaskell/stack/issues/3562) * Fixes a bug that has existed since 1.5.0, where `stack setup --upgrade-cabal` would say that Cabal is already the latest version, when it wasn't. * Ensure that an `extra-dep` from a local directory is not treated as a `$locals` for GHC options purposes. See [#3574](https://github.com/commercialhaskell/stack/issues/3574). * Building all executables only happens once instead of every time. See [#3229](https://github.com/commercialhaskell/stack/issues/3229) for more info. ## 1.5.1 Bug fixes: * Stack eagerly tries to parse all cabal files related to a snapshot. Starting with Stackage Nightly 2017-07-31, snapshots are using GHC 8.2.1, and the `ghc.cabal` file implicitly referenced uses the (not yet supported) Cabal 2.0 file format. Future releases of Stack will both be less eager about cabal file parsing and support Cabal 2.0. This patch simply bypasses the error for invalid parsing. ## 1.5.0 Behavior changes: * `stack profile` and `stack trace` now add their extra RTS arguments for benchmarks and tests to the beginning of the args, instead of the end. See [#2399](https://github.com/commercialhaskell/stack/issues/2399) * Support for Git-based indices has been removed. Other enhancements: * `stack setup` allow to control options passed to ghcjs-boot with `--ghcjs-boot-options` (one word at a time) and `--[no-]ghcjs-boot-clean` * `stack setup` now accepts a `--install-cabal VERSION` option which will install a specific version of the Cabal library globally. * Updates to store-0.4.1, which has improved performance and better error reporting for version tags. A side-effect of this is that all of stack's binary caches will be invalidated. * `stack solver` will now warn about unexpected cabal-install versions. See [#3044](https://github.com/commercialhaskell/stack/issues/3044) * Upstream packages unpacked to a temp dir are now deleted as soon as possible to avoid running out of space in `/tmp`. See [#3018](https://github.com/commercialhaskell/stack/issues/3018) * Add short synonyms for `test-arguments` and `benchmark-arguments` options. * Adds `STACK_WORK` environment variable, to specify work dir. See [#3063](https://github.com/commercialhaskell/stack/issues/3063) * Can now use relative paths for `extra-include-dirs` and `extra-lib-dirs`. See [#2830](https://github.com/commercialhaskell/stack/issues/2830) * Improved bash completion for many options, including `--ghc-options`, `--flag`, targets, and project executables for `exec`. * `--haddock-arguments` is actually used now when `haddock` is invoked during documentation generation. * `--[no-]haddock-hyperlink-source` flag added which allows toggling of sources being included in Haddock output. See [#3099](https://github.com/commercialhaskell/stack/issues/3099) * `stack ghci` will now skip building all local targets, even if they have downstream deps, as long as it's registered in the DB. * The pvp-bounds feature now supports adding `-revision` to the end of each value, e.g. `pvp-bounds: both-revision`. This means that, when uploading to Hackage, Stack will first upload your tarball with an unmodified `.cabal` file, and then upload a cabal file revision with the PVP bounds added. This can be useful—especially combined with the [Stackage no-revisions feature](http://www.snoyman.com/blog/2017/04/stackages-no-revisions-field)—as a method to ensure PVP compliance without having to proactively fix bounds issues for Stackage maintenance. * Expose a `save-hackage-creds` configuration option * On GHC <= 7.8, filters out spurious linker warnings on windows See [#3127](https://github.com/commercialhaskell/stack/pull/3127) * Better error messages when creating or building packages which alias wired-in packages. See [#3172](https://github.com/commercialhaskell/stack/issues/3172). * MinGW bin folder now is searched for dynamic libraries. See [#3126](https://github.com/commercialhaskell/stack/issues/3126) * When using Nix, nix-shell now depends always on git to prevent runtime errors while fetching metadata * The `stack unpack` command now accepts a form where an explicit Hackage revision hash is specified, e.g. `stack unpack foo-1.2.3@gitsha1:deadbeef`. Note that this should be considered _experimental_, Stack will likely move towards a different hash format in the future. * Binary "stack upgrade" will now warn if the installed executable is not on the PATH or shadowed by another entry. * Allow running tests on tarball created by sdist and upload [#717](https://github.com/commercialhaskell/stack/issues/717). Bug fixes: * Fixes case where `stack build --profile` might not cause executables / tests / benchmarks to be rebuilt. See [#2984](https://github.com/commercialhaskell/stack/issues/2984) * `stack ghci file.hs` now loads the file even if it isn't part of your project. * `stack clean --full` now works when docker is enabled. See [#2010](https://github.com/commercialhaskell/stack/issues/2010) * Fixes an issue where cyclic deps can cause benchmarks or tests to be run before they are built. See [#2153](https://github.com/commercialhaskell/stack/issues/2153) * Fixes `stack build --file-watch` in cases where a directory is removed See [#1838](https://github.com/commercialhaskell/stack/issues/1838) * Fixes `stack dot` and `stack list-dependencies` to use info from the package database for wired-in-packages (ghc, base, etc). See [#3084](https://github.com/commercialhaskell/stack/issues/3084) * Fixes `stack --docker build` when user is part of libvirt/libvirtd groups on Ubuntu Yakkety (16.10). See [#3092](https://github.com/commercialhaskell/stack/issues/3092) * Switching a package between extra-dep and local package now forces rebuild (previously it wouldn't if versions were the same). See [#2147](https://github.com/commercialhaskell/stack/issues/2147) * `stack upload` no longer reveals your password when you type it on MinTTY-based Windows shells, such as Cygwin and MSYS2. See [#3142](https://github.com/commercialhaskell/stack/issues/3142) * `stack script`'s import parser will now properly parse files that have Windows-style line endings (CRLF) ## 1.4.0 Release notes: * Docker images: [fpco/stack-full](https://hub.docker.com/r/fpco/stack-full/) and [fpco/stack-run](https://hub.docker.com/r/fpco/stack-run/) are no longer being built for LTS 8.0 and above. [fpco/stack-build](https://hub.docker.com/r/fpco/stack-build/) images continue to be built with a [simplified process](https://github.com/commercialhaskell/stack/tree/master/etc/dockerfiles/stack-build). [#624](https://github.com/commercialhaskell/stack/issues/624) Major changes: * A new command, `script`, has been added, intended to make the script interpreter workflow more reliable, easier to use, and more efficient. This command forces the user to provide a `--resolver` value, ignores all config files for more reproducible results, and optimizes the existing package check to make the common case of all packages already being present much faster. This mode does require that all packages be present in a snapshot, however. [#2805](https://github.com/commercialhaskell/stack/issues/2805) Behavior changes: * The default package metadata backend has been changed from Git to the 01-index.tar.gz file, from the hackage-security project. This is intended to address some download speed issues from Github for people in certain geographic regions. There is now full support for checking out specific cabal file revisions from downloaded tarballs as well. If you manually specify a package index with only a Git URL, Git will still be used. See [#2780](https://github.com/commercialhaskell/stack/issues/2780) * When you provide the `--resolver` argument to the `stack unpack` command, any packages passed in by name only will be looked up in the given snapshot instead of taking the latest version. For example, `stack --resolver lts-7.14 unpack mtl` will get version 2.2.1 of `mtl`, regardless of the latest version available in the package indices. This will also force the same cabal file revision to be used as is specified in the snapshot. Unpacking via a package identifier (e.g. `stack --resolver lts-7.14 unpack mtl-2.2.1`) will ignore any settings in the snapshot and take the most recent revision. For backwards compatibility with tools relying on the presence of a `00-index.tar`, Stack will copy the `01-index.tar` file to `00-index.tar`. Note, however, that these files are different; most importantly, 00-index contains only the newest revisions of cabal files, while 01-index contains all versions. You may still need to update your tooling. * Passing `--(no-)nix-*` options now no longer implies `--nix`, except for `--nix-pure`, so that the user preference whether or not to use Nix is honored even in the presence of options that change the Nix behavior. Other enhancements: * Internal cleanup: configuration types are now based much more on lenses * `stack build` and related commands now allow the user to disable debug symbol stripping with new `--no-strip`, `--no-library-stripping`, and `--no-executable-shipping` flags, closing [#877](https://github.com/commercialhaskell/stack/issues/877). Also turned error message for missing targets more readable ([#2384](https://github.com/commercialhaskell/stack/issues/2384)) * `stack haddock` now shows index.html paths when documentation is already up to date. Resolved [#781](https://github.com/commercialhaskell/stack/issues/781) * Respects the `custom-setup` field introduced in Cabal 1.24. This supercedes any `explicit-setup-deps` settings in your `stack.yaml` and trusts the package's `.cabal` file to explicitly state all its dependencies. * If system package installation fails, `get-stack.sh` will fail as well. Also shows warning suggesting to run `apt-get update` or similar, depending on the OS. ([#2898](https://github.com/commercialhaskell/stack/issues/2898)) * When `stack ghci` is run with a config with no packages (e.g. global project), it will now look for source files in the current work dir. ([#2878](https://github.com/commercialhaskell/stack/issues/2878)) * Bump to hpack 0.17.0 to allow `custom-setup` and `!include "..."` in `package.yaml`. * The script interpreter will now output error logging. In particular, this means it will output info about plan construction errors. ([#2879](https://github.com/commercialhaskell/stack/issues/2879)) * `stack ghci` now takes `--flag` and `--ghc-options` again (inadvertently removed in 1.3.0). ([#2986](https://github.com/commercialhaskell/stack/issues/2986)) * `stack exec` now takes `--rts-options` which passes the given arguments inside of `+RTS ... args .. -RTS` to the executable. This works around stack itself consuming the RTS flags on Windows. ([#2640](https://github.com/commercialhaskell/stack/issues/2640)) * Upgraded `http-client-tls` version, which now offers support for the `socks5://` and `socks5h://` values in the `http_proxy` and `https_proxy` environment variables. Bug fixes: * Bump to hpack 0.16.0 to avoid character encoding issues when reading and writing on non-UTF8 systems. * `stack ghci` will no longer ignore hsSourceDirs that contain `..`. ([#2895](https://github.com/commercialhaskell/stack/issues/2895)) * `stack list-dependencies --license` now works for wired-in-packages, like base. ([#2871](https://github.com/commercialhaskell/stack/issues/2871)) * `stack setup` now correctly indicates when it uses system ghc ([#2963](https://github.com/commercialhaskell/stack/issues/2963)) * Fix to `stack config set`, in 1.3.2 it always applied to the global project. ([#2709](https://github.com/commercialhaskell/stack/issues/2709)) * Previously, cabal files without exe or lib would fail on the "copy" step. ([#2862](https://github.com/commercialhaskell/stack/issues/2862)) * `stack upgrade --git` now works properly. Workaround for affected versions (>= 1.3.0) is to instead run `stack upgrade --git --source-only`. ([#2977](https://github.com/commercialhaskell/stack/issues/2977)) * Added support for GHC 8's slightly different warning format for dumping warnings from logs. * Work around a bug in Cabal/GHC in which package IDs are not unique for different source code, leading to Stack not always rebuilding packages depending on local packages which have changed. ([#2904](https://github.com/commercialhaskell/stack/issues/2904)) ## 1.3.2 Bug fixes: * `stack config set` can now be used without a compiler installed [#2852](https://github.com/commercialhaskell/stack/issues/2852). * `get-stack.sh` now installs correct binary on ARM for generic linux and raspbian, closing [#2856](https://github.com/commercialhaskell/stack/issues/2856). * Correct the testing of whether a package database exists by checking for the `package.cache` file itself instead of the containing directory. * Revert a change in the previous release which made it impossible to set local extra-dep packages as targets. This was overkill; we really only wanted to disable their test suites, which was already handled by a later patch. [#2849](https://github.com/commercialhaskell/stack/issues/2849) * `stack new` always treats templates as being UTF-8 encoding, ignoring locale settings on a local machine. See [Yesod mailing list discussion](https://groups.google.com/d/msg/yesodweb/ZyWLsJOtY0c/aejf9E7rCAAJ) ## 1.3.0 Release notes: * For the _next_ stack release after this one, we are planning changes to our Linux releases, including dropping our Ubuntu, Debian, CentOS, and Fedora package repositories and switching to statically linked binaries. See [#2534](https://github.com/commercialhaskell/stack/issues/2534). Note that upgrading without a package manager has gotten easier with new binary upgrade support in `stack upgrade` (see the Major Changes section below for more information). In addition, the get.haskellstack.org script no longer installs from Ubuntu, Debian, CentOS, or Fedora package repositories. Instead it places a generic binary in /usr/local/bin. Major changes: * Stack will now always use its own GHC installation, even when a suitable GHC installation is available on the PATH. To get the old behaviour, use the `--system-ghc` flag or run `stack config set system-ghc --global true`. Docker- and Nix-enabled projects continue to use the GHC installations in their environment by default. NB: Scripts that previously used stack in combination with a system GHC installation should now include a `stack setup` line or use the `--install-ghc` flag. [#2221](https://github.com/commercialhaskell/stack/issues/2221) * `stack ghci` now defaults to skipping the build of target packages, because support has been added for invoking "initial build steps", which create autogen files and run preprocessors. The `--no-build` flag is now deprecated because it should no longer be necessary. See [#1364](https://github.com/commercialhaskell/stack/issues/1364) * Stack is now capable of doing binary upgrades instead of always recompiling a new version from source. Running `stack upgrade` will now default to downloading a binary version of Stack from the most recent release, if one is available. See `stack upgrade --help` for more options. [#1238](https://github.com/commercialhaskell/stack/issues/1238) Behavior changes: * Passing `--resolver X` with a Stack command which forces creation of a global project config, will pass resolver X into the initial config. See [#2579](https://github.com/commercialhaskell/stack/issues/2229). * Switch the "Run from outside project" messages to debug-level, to avoid spamming users in the normal case of non-project usage * If a remote package is specified (such as a Git repo) without an explicit `extra-dep` setting, a warning is given to the user to provide one explicitly. Other enhancements: * `stack haddock` now supports `--haddock-internal`. See [#2229](https://github.com/commercialhaskell/stack/issues/2229) * Add support for `system-ghc` and `install-ghc` fields to `stack config set` command. * Add `ghc-build` option to override autodetected GHC build to use (e.g. gmp4, tinfo6, nopie) on Linux. * `stack setup` detects systems where gcc enables PIE by default (such as Ubuntu 16.10 and Hardened Gentoo) and adjusts the GHC `configure` options accordingly. [#2542](https://github.com/commercialhaskell/stack/issues/2542) * Upload to Hackage with HTTP digest instead of HTTP basic. * Make `stack list-dependencies` understand all of the `stack dot` options too. * Add the ability for `stack list-dependencies` to list dependency licenses by passing the `--license` flag. * Dump logs that contain warnings for any local non-dependency packages [#2545](https://github.com/commercialhaskell/stack/issues/2545) * Add the `dump-logs` config option and `--dump-logs` command line option to get full build output on the console. [#426](https://github.com/commercialhaskell/stack/issues/426) * Add the `--open` option to "stack hpc report" command, causing the report to be opened in the browser. * The `stack config set` command now accepts a `--global` flag for suitable fields which causes it to modify the global user configuration (`~/.stack/config.yaml`) instead of the project configuration. [#2675](https://github.com/commercialhaskell/stack/pull/2675) * Information on the latest available snapshots is now downloaded from S3 instead of stackage.org, increasing reliability in case of stackage.org outages. [#2653](https://github.com/commercialhaskell/stack/pull/2653) * `stack dot` and `stack list-dependencies` now take targets and flags. [#1919](https://github.com/commercialhaskell/stack/issues/1919) * Deprecate `stack setup --stack-setup-yaml` for `--setup-info-yaml` based on discussion in [#2647](https://github.com/commercialhaskell/stack/issues/2647). * The `--main-is` flag for GHCI now implies the TARGET, fixing [#1845](https://github.com/commercialhaskell/stack/issues/1845). * `stack ghci` no longer takes all build options, as many weren't useful [#2199](https://github.com/commercialhaskell/stack/issues/2199) * `--no-time-in-log` option, to make verbose logs more diffable [#2727](https://github.com/commercialhaskell/stack/issues/2727) * `--color` option added to override auto-detection of ANSI support [#2725](https://github.com/commercialhaskell/stack/issues/2725) * Missing extra-deps are now warned about, adding a degree of typo detection [#1521](https://github.com/commercialhaskell/stack/issues/1521) * No longer warns about missing build-tools if they are on the PATH. [#2235](https://github.com/commercialhaskell/stack/issues/2235) * Replace enclosed-exceptions with safe-exceptions. [#2768](https://github.com/commercialhaskell/stack/issues/2768) * The install location for GHC and other programs can now be configured with the `local-programs-path` option in `config.yaml`. [#1644](https://github.com/commercialhaskell/stack/issues/1644) * Added option to add nix dependencies as nix GC roots * Proper pid 1 (init) process for `stack exec` with Docker * Dump build logs if they contain warnings. [#2545](https://github.com/commercialhaskell/stack/issues/2545) * Docker: redirect stdout of `docker pull` to stderr so that it will not interfere with output of other commands. * Nix & docker can be activated at the same time, in order to run stack in a nix-shell in a container, preferably from an image already containing the nix dependencies in its /nix/store * Stack/nix: Dependencies can be added as nix GC roots, so they are not removed when running `nix-collect-garbage` Bug fixes: * Fixed a gnarly bug where programs and package tarballs sometimes have corrupted downloads. See [#2657](https://github.com/commercialhaskell/stack/issues/2568). * Add proper support for non-ASCII characters in file paths for the `sdist` command. See [#2549](https://github.com/commercialhaskell/stack/issues/2549) * Never treat `extra-dep` local packages as targets. This ensures things like test suites are not run for these packages, and that build output is not hidden due to their presence. * Fix a resource leak in `sinkProcessStderrStdout` which could affect much of the codebase, in particular copying precompiled packages. [#1979](https://github.com/commercialhaskell/stack/issues/1979) * Docker: ensure that interrupted extraction process does not cause corrupt file when downloading a Docker-compatible Stack executable [#2568](https://github.com/commercialhaskell/stack/issues/2568) * Fixed running `stack hpc report` on package targets. [#2664](https://github.com/commercialhaskell/stack/issues/2664) * Fix a long-standing performance regression where stack would parse the .dump-hi files of the library components of local packages twice. [#2658](https://github.com/commercialhaskell/stack/pull/2658) * Fixed a regression in "stack ghci --no-load", where it would prompt for a main module to load. [#2603](https://github.com/commercialhaskell/stack/pull/2603) * Build Setup.hs files with the threaded RTS, mirroring the behavior of cabal-install and enabling more complex build systems in those files. * Fixed a bug in passing along `--ghc-options` to ghcjs. They were being provided as `--ghc-options` to Cabal, when it needs to be `--ghcjs-options`. [#2714](https://github.com/commercialhaskell/stack/issues/2714) * Launch Docker from the project root regardless of the working directory Stack is invoked from. This means paths relative to the project root (e.g. environment files) can be specified in `stack.yaml`'s docker `run-args`. * `stack setup --reinstall` now behaves as expected. [#2554](https://github.com/commercialhaskell/stack/issues/2554) ## 1.2.0 Release notes: * On many Un*x systems, Stack can now be installed with a simple one-liner: wget -qO- https://get.haskellstack.org/ | sh * The fix for [#2175](https://github.com/commercialhaskell/stack/issues/2175) entails that stack must perform a full clone of a large Git repo of Hackage meta-information. The total download size is about 200 MB. Please be aware of this when upgrading your stack installation. * If you use Mac OS X, you may want to delay upgrading to macOS Sierra as there are reports of GHC panics when building some packages (including Stack itself). See [#2577](https://github.com/commercialhaskell/stack/issues/2577) * This version of Stack does not build on ARM or PowerPC systems (see [store#37](https://github.com/fpco/store/issues/37)). Please stay with version 1.1.2 for now on those architectures. This will be rectified soon! * We are now releasing a [statically linked Stack binary for 64-bit Linux](https://get.haskellstack.org/stable/linux-x86_64-static.tar.gz). Please try it and let us know if you run into any trouble on your platform. * We are planning some changes to our Linux releases, including dropping our Ubuntu, Debian, CentOS, and Fedora package repositories and switching to statically linked binaries. We would value your feedback in [#2534](https://github.com/commercialhaskell/stack/issues/2534). Major changes: * Add `stack hoogle` command. [#55](https://github.com/commercialhaskell/stack/issues/55) * Support for absolute file path in `url` field of `setup-info` or `--ghc-bindist` * Add support for rendering GHCi scripts targeting different GHCi like applications [#2457](https://github.com/commercialhaskell/stack/pull/2457) Behavior changes: * Remove `stack ide start` and `stack ide load-targets` commands. [#2178](https://github.com/commercialhaskell/stack/issues/2178) * Support .buildinfo files in `stack ghci`. [#2242](https://github.com/commercialhaskell/stack/pull/2242) * Support -ferror-spans syntax in GHC error messages. * Avoid unpacking ghc to `/tmp` [#996](https://github.com/commercialhaskell/stack/issues/996) * The Linux `gmp4` GHC bindist is no longer considered a full-fledged GHC variant and can no longer be specified using the `ghc-variant` option, and instead is treated more like a slightly different platform. Other enhancements: * Use the `store` package for binary serialization of most caches. * Only require minor version match for Docker stack exe. This way, we can make patch releases for version bounds and similar build issues without needing to upload new binaries for Docker. * Stack/Nix: Passes the right ghc derivation as an argument to the `shell.nix` when a custom `shell.nix` is used See [#2243](https://github.com/commercialhaskell/stack/issues/2243) * Stack/Nix: Sets `LD_LIBRARY_PATH` so packages using C libs for Template Haskell can work (See _e.g._ [this HaskellR issue](https://github.com/tweag/HaskellR/issues/253)) * Parse CLI arguments and configuration files into less permissive types, improving error messages for bad inputs. [#2267](https://github.com/commercialhaskell/stack/issues/2267) * Add the ability to explicitly specify a gcc executable. [#593](https://github.com/commercialhaskell/stack/issues/593) * Nix: No longer uses LTS mirroring in nixpkgs. Gives to nix-shell a derivation like `haskell.compiler.ghc801` See [#2259](https://github.com/commercialhaskell/stack/issues/2259) * Perform some subprocesses during setup concurrently, slightly speeding up most commands. [#2346](https://github.com/commercialhaskell/stack/pull/2346) * `stack setup` no longer unpacks to the system temp dir on posix systems. [#996](https://github.com/commercialhaskell/stack/issues/996) * `stack setup` detects libtinfo6 and ncurses6 and can download alternate GHC bindists [#257](https://github.com/commercialhaskell/stack/issues/257) [#2302](https://github.com/commercialhaskell/stack/issues/2302). * `stack setup` detects Linux ARMv7 downloads appropriate GHC bindist [#2103](https://github.com/commercialhaskell/stack/issues/2103) * Custom `stack` binaries list dependency versions in output for `--version`. See [#2222](https://github.com/commercialhaskell/stack/issues/2222) and [#2450](https://github.com/commercialhaskell/stack/issues/2450). * Use a pretty printer to output dependency resolution errors. [#1912](https://github.com/commercialhaskell/stack/issues/1912) * Remove the `--os` flag [#2227](https://github.com/commercialhaskell/stack/issues/2227) * Add 'netbase' and 'ca-certificates' as dependency for .deb packages. [#2293](https://github.com/commercialhaskell/stack/issues/2293). * Add `stack ide targets` command. * Enhance debug logging with subprocess timings. * Pretty-print YAML parse errors [#2374](https://github.com/commercialhaskell/stack/issues/2374) * Clarify confusing `stack setup` output [#2314](https://github.com/commercialhaskell/stack/issues/2314) * Delete `Stack.Types` multimodule to improve build times [#2405](https://github.com/commercialhaskell/stack/issues/2405) * Remove spurious newlines in build logs [#2418](https://github.com/commercialhaskell/stack/issues/2418) * Interpreter: Provide a way to hide implicit packages [#1208](https://github.com/commercialhaskell/stack/issues/1208) * Check executability in exec lookup [#2489](https://github.com/commercialhaskell/stack/issues/2489) Bug fixes: * Fix cabal warning about use of a deprecated cabal flag [#2350](https://github.com/commercialhaskell/stack/issues/2350) * Support most executable extensions on Windows [#2225](https://github.com/commercialhaskell/stack/issues/2225) * Detect resolver change in `stack solver` [#2252](https://github.com/commercialhaskell/stack/issues/2252) * Fix a bug in docker image creation where the wrong base image was selected [#2376](https://github.com/commercialhaskell/stack/issues/2376) * Ignore special entries when unpacking tarballs [#2361](https://github.com/commercialhaskell/stack/issues/2361) * Fixes src directory pollution of `style.css` and `highlight.js` with GHC 8's haddock [#2429](https://github.com/commercialhaskell/stack/issues/2429) * Handle filepaths with spaces in `stack ghci` [#2266](https://github.com/commercialhaskell/stack/issues/2266) * Apply ghc-options to snapshot packages [#2289](https://github.com/commercialhaskell/stack/issues/2289) * stack sdist: Fix timestamp in tarball [#2394](https://github.com/commercialhaskell/stack/pull/2394) * Allow global Stack arguments with a script [#2316](https://github.com/commercialhaskell/stack/issues/2316) * Inconsistency between ToJSON and FromJSON instances of PackageLocation [#2412](https://github.com/commercialhaskell/stack/pull/2412) * Perform Unicode normalization on filepaths [#1810](https://github.com/commercialhaskell/stack/issues/1810) * Solver: always keep ghc wired-in as hard constraints [#2453](https://github.com/commercialhaskell/stack/issues/2453) * Support OpenBSD's tar where possible, require GNU tar for xz support [#2283](https://github.com/commercialhaskell/stack/issues/2283) * Fix using --coverage with Cabal-1.24 [#2424](https://github.com/commercialhaskell/stack/issues/2424) * When marking exe installed, remove old version [#2373](https://github.com/commercialhaskell/stack/issues/2373) * Stop truncating all-cabal-hashes git repo [#2175](https://github.com/commercialhaskell/stack/issues/2175) * Handle non-ASCII filenames on Windows [#2491](https://github.com/commercialhaskell/stack/issues/2491) * Avoid using multiple versions of a package in script interpreter by passing package-id to ghc/runghc [#1957](https://github.com/commercialhaskell/stack/issues/1957) * Only pre-load compiler version when using nix integration [#2459](https://github.com/commercialhaskell/stack/issues/2459) * Solver: parse cabal errors also on Windows [#2502](https://github.com/commercialhaskell/stack/issues/2502) * Allow exec and ghci commands in interpreter mode. Scripts can now automatically open in the repl by using `exec ghci` instead of `runghc` in the shebang command. [#2510](https://github.com/commercialhaskell/stack/issues/2510) * Now consider a package to be dirty when an extra-source-file is changed. See [#2040](https://github.com/commercialhaskell/stack/issues/2040) ## 1.1.2 Release notes: * Official FreeBSD binaries are [now available](http://docs.haskellstack.org/en/stable/install_and_upgrade/#freebsd) [#1253](https://github.com/commercialhaskell/stack/issues/1253). Major changes: * Extensible custom snapshots implemented. These allow you to define snapshots which extend other snapshots. See [#863](https://github.com/commercialhaskell/stack/issues/863). Local file custom snapshots can now be safely updated without changing their name. Remote custom snapshots should still be treated as immutable. Behavior changes: * `stack path --compiler` was added in the last release, to yield a path to the compiler. Unfortunately, `--compiler` is a global option that is useful to use with `stack path`. The same functionality is now provided by `stack path --compiler-exe`. See [#2123](https://github.com/commercialhaskell/stack/issues/2123) * For packages specified in terms of a git or hg repo, the hash used in the location has changed. This means that existing downloads from older stack versions won't be used. This is a side-effect of the fix to [#2133](https://github.com/commercialhaskell/stack/issues/2133) * `stack upgrade` no longer pays attention to local stack.yaml files, just the global config and CLI options. [#1392](https://github.com/commercialhaskell/stack/issues/1392) * `stack ghci` now uses `:add` instead of `:load`, making it potentially work better with user scripts. See [#1888](https://github.com/commercialhaskell/stack/issues/1888) Other enhancements: * Grab Cabal files via Git SHA to avoid regressions from Hackage revisions [#2070](https://github.com/commercialhaskell/stack/pull/2070) * Custom snapshots now support `ghc-options`. * Package git repos are now re-used rather than re-cloned. See [#1620](https://github.com/commercialhaskell/stack/issues/1620) * `DESTDIR` is filtered from environment when installing GHC. See [#1460](https://github.com/commercialhaskell/stack/issues/1460) * `stack haddock` now supports `--hadock-arguments`. See [#2144](https://github.com/commercialhaskell/stack/issues/2144) * Signing: warn if GPG_TTY is not set as per `man gpg-agent` Bug fixes: * Now ignore project config when doing `stack init` or `stack new`. See [#2110](https://github.com/commercialhaskell/stack/issues/2110) * Packages specified by git repo can now have submodules. See [#2133](https://github.com/commercialhaskell/stack/issues/2133) * Fix of hackage index fetch retry. See re-opening of [#1418](https://github.com/commercialhaskell/stack/issues/1418#issuecomment-217633843) * HPack now picks up changes to filesystem other than package.yaml. See [#2051](https://github.com/commercialhaskell/stack/issues/2051) * "stack solver" no longer suggests --omit-packages. See [#2031](https://github.com/commercialhaskell/stack/issues/2031) * Fixed an issue with building Cabal's Setup.hs. See [#1356](https://github.com/commercialhaskell/stack/issues/1356) * Package dirtiness now pays attention to deleted files. See [#1841](https://github.com/commercialhaskell/stack/issues/1841) * `stack ghci` now uses `extra-lib-dirs` and `extra-include-dirs`. See [#1656](https://github.com/commercialhaskell/stack/issues/1656) * Relative paths outside of source dir added via `qAddDependentFile` are now checked for dirtiness. See [#1982](https://github.com/commercialhaskell/stack/issues/1982) * Signing: always use `--with-fingerprints` ## 1.1.0 Release notes: * Added Ubuntu 16.04 LTS (xenial) Apt repo. * No longer uploading new versions to Fedora 21 repo. Behavior changes: * Snapshot packages are no longer built with executable profiling. See [#1179](https://github.com/commercialhaskell/stack/issues/1179). * `stack init` now ignores symlinks when searching for cabal files. It also now ignores any directory that begins with `.` (as well as `dist` dirs) - before it would only ignore `.git`, `.stack-work`, and `dist`. * The stack executable is no longer built with `-rtsopts`. Before, when `-rtsopts` was enabled, stack would process `+RTS` options even when intended for some other program, such as when used with `stack exec -- prog +RTS`. See [#2022](https://github.com/commercialhaskell/stack/issues/2022). * The `stack path --ghc-paths` option is deprecated and renamed to `--programs`. `--compiler` is added, which points directly at the compiler used in the current project. `--compiler-bin` points to the compiler's bin dir. * For consistency with the `$STACK_ROOT` environment variable, the `stack path --global-stack-root` flag and the `global-stack-root` field in the output of `stack path` are being deprecated and replaced with the `stack-root` flag and output field. Additionally, the stack root can now be specified via the `--stack-root` command-line flag. See [#1148](https://github.com/commercialhaskell/stack/issues/1148). * `stack sig` GPG-related sub-commands were removed (folded into `upload` and `sdist`) * GPG signing of packages while uploading to Hackage is now the default. Use `upload --no-signature` if you would rather not contribute your package signature. If you don't yet have a GPG keyset, read this [blog post on GPG keys](https://fpcomplete.com/blog/2016/05/stack-security-gnupg-keys). We can add a stack.yaml config setting to disable signing if some people desire it. We hope that people will sign. Later we will be adding GPG signature verification options. * `stack build pkg-1.2.3` will now build even if the snapshot has a different package version - it is treated as an extra-dep. `stack build local-pkg-1.2.3` is an error even if the version number matches the local package [#2028](https://github.com/commercialhaskell/stack/issues/2028). * Having a `nix:` section no longer implies enabling nix build. This allows the user to globally configure whether nix is used (unless the project overrides the default explicitly). See [#1924](https://github.com/commercialhaskell/stack/issues/1924). * Remove deprecated valid-wanted field. * Docker: mount home directory in container [#1949](https://github.com/commercialhaskell/stack/issues/1949). * Deprecate `--local-bin-path` instead `--local-bin`. * `stack image`: allow absolute source paths for `add`. Other enhancements: * `stack haddock --open [PACKAGE]` opens the local haddocks in the browser. * Fix too much rebuilding when enabling/disabling profiling flags. * `stack build pkg-1.0` will now build `pkg-1.0` even if the snapshot specifies a different version (it introduces a temporary extra-dep) * Experimental support for `--split-objs` added [#1284](https://github.com/commercialhaskell/stack/issues/1284). * `git` packages with submodules are supported by passing the `--recursive` flag to `git clone`. * When using [hpack](https://github.com/sol/hpack), only regenerate cabal files when hpack files change. * hpack files can now be used in templates * `stack ghci` now runs ghci as a separate process [#1306](https://github.com/commercialhaskell/stack/issues/1306) * Retry when downloading snapshots and package indices * Many build options are configurable now in `stack.yaml`: ``` build: library-profiling: true executable-profiling: true haddock: true haddock-deps: true copy-bins: true prefetch: true force-dirty: true keep-going: true test: true test-arguments: rerun-tests: true additional-args: ['-fprof'] coverage: true no-run-tests: true bench: true benchmark-opts: benchmark-arguments: -O2 no-run-benchmarks: true reconfigure: true cabal-verbose: true ``` * A number of URLs are now configurable, useful for firewalls. See [#1794](https://github.com/commercialhaskell/stack/issues/1884). * Suggest causes when executables are missing. * Allow `--omit-packages` even without `--solver`. * Improve the generated stack.yaml. * Improve ghci results after :load Main module collision with main file path. * Only load the hackage index if necessary [#1883](https://github.com/commercialhaskell/stack/issues/1883), [#1892](https://github.com/commercialhaskell/stack/issues/1892). * init: allow local packages to be deps of deps [#1965](https://github.com/commercialhaskell/stack/issues/1965). * Always use full fingerprints from GPG [#1952](https://github.com/commercialhaskell/stack/issues/1952). * Default to using `gpg2` and fall back to `gpg` [#1976](https://github.com/commercialhaskell/stack/issues/1976). * Add a flag for --verbosity silent. * Add `haddock --open` flag [#1396](https://github.com/commercialhaskell/stack/issues/1396). Bug fixes: * Package tarballs would fail to unpack. [#1884](https://github.com/commercialhaskell/stack/issues/1884). * Fixed errant warnings about missing modules, after deleted and removed from cabal file [#921](https://github.com/commercialhaskell/stack/issues/921) [#1805](https://github.com/commercialhaskell/stack/issues/1805). * Now considers a package to dirty when the hpack file is changed [#1819](https://github.com/commercialhaskell/stack/issues/1819). * Nix: cancelling a stack build now exits properly rather than dropping into a nix-shell [#1778](https://github.com/commercialhaskell/stack/issues/1778). * `allow-newer: true` now causes `--exact-configuration` to be passed to Cabal. See [#1579](https://github.com/commercialhaskell/stack/issues/1579). * `stack solver` no longer fails with `InvalidRelFile` for relative package paths including `..`. See [#1954](https://github.com/commercialhaskell/stack/issues/1954). * Ignore emacs lock files when finding .cabal [#1897](https://github.com/commercialhaskell/stack/issues/1897). * Use lenient UTF-8 decode for build output [#1945](https://github.com/commercialhaskell/stack/issues/1945). * Clear index cache whenever index updated [#1962](https://github.com/commercialhaskell/stack/issues/1962). * Fix: Building a container image drops a .stack-work dir in the current working (sub)directory [#1975](https://github.com/commercialhaskell/stack/issues/1975). * Fix: Rebuilding when disabling profiling [#2023](https://github.com/commercialhaskell/stack/issues/2023). ## 1.0.4.3 Bug fixes: * Don't delete contents of ~/.ssh when using `stack clean --full` with Docker enabled [#2000](https://github.com/commercialhaskell/stack/issues/2000) ## 1.0.4.2 Build with path-io-1.0.0. There are no changes in behaviour from 1.0.4, so no binaries are released for this version. ## 1.0.4.1 Fixes build with aeson-0.11.0.0. There are no changes in behaviour from 1.0.4, so no binaries are released for this version. ## 1.0.4 Major changes: * Some notable changes in `stack init`: * Overall it should now be able to initialize almost all existing cabal packages out of the box as long as the package itself is consistently defined. * Choose the best possible snapshot and add extra dependencies on top of a snapshot resolver rather than a compiler resolver - [#1583](https://github.com/commercialhaskell/stack/pull/1583) * Automatically omit a package (`--omit-packages`) when it is compiler incompatible or when there are packages with conflicting dependency requirements - [#1674](https://github.com/commercialhaskell/stack/pull/1674). * Some more changes for a better user experience. Please refer to the doc guide for details. * Add support for hpack, alternative package description format [#1679](https://github.com/commercialhaskell/stack/issues/1679) Other enhancements: * Docker: pass ~/.ssh and SSH auth socket into container, so that git repos work [#1358](https://github.com/commercialhaskell/stack/issues/1358). * Docker: strip suffix from docker --version. [#1653](https://github.com/commercialhaskell/stack/issues/1653) * Docker: pass USER and PWD environment variables into container. * On each run, stack will test the stack root directory (~/.stack), and the project and package work directories (.stack-work) for whether they are owned by the current user and abort if they are not. This precaution can be disabled with the `--allow-different-user` flag or `allow-different-user` option in the global config (~/.stack/config.yaml). [#471](https://github.com/commercialhaskell/stack/issues/471) * Added `stack clean --full` option for full working dir cleanup. * YAML config: support Zip archives. * Redownload build plan if parsing fails [#1702](https://github.com/commercialhaskell/stack/issues/1702). * Give mustache templates access to a 'year' tag [#1716](https://github.com/commercialhaskell/stack/pull/1716). * Have "stack ghci" warn about module name aliasing. * Add "stack ghci --load-local-deps". * Build Setup.hs with -rtsopts [#1687](https://github.com/commercialhaskell/stack/issues/1687). * `stack init` accepts a list of directories. * Add flag infos to DependencyPlanFailures (for better error output in case of flags) [#713](https://github.com/commercialhaskell/stack/issues/713) * `stack new --bare` complains for overwrites, and add `--force` option [#1597](https://github.com/commercialhaskell/stack/issues/1597). Bug fixes: * Previously, `stack ghci` would fail with `cannot satisfy -package-id` when the implicit build step changes the package key of some dependency. * Fix: Building with ghcjs: "ghc-pkg: Prelude.chr: bad argument: 2980338" [#1665](https://github.com/commercialhaskell/stack/issues/1665). * Fix running test / bench with `--profile` / `--trace`. * Fix: build progress counter is no longer visible [#1685](https://github.com/commercialhaskell/stack/issues/1685). * Use "-RTS" w/ profiling to allow extra args [#1772](https://github.com/commercialhaskell/stack/issues/1772). * Fix withUnpackedTarball7z to find name of srcDir after unpacking (fixes `stack setup` fails for ghcjs project on windows) [#1774](https://github.com/commercialhaskell/stack/issues/1774). * Add space before auto-generated bench opts (makes profiling options work uniformly for applications and benchmark suites) [#1771](https://github.com/commercialhaskell/stack/issues/1771). * Don't try to find plugin if it resembles flag. * Setup.hs changes cause package dirtiness [#1711](https://github.com/commercialhaskell/stack/issues/1711). * Send "stack templates" output to stdout [#1792](https://github.com/commercialhaskell/stack/issues/1792). ## 1.0.2 Release notes: - Arch Linux: Stack has been adopted into the [official community repository](https://www.archlinux.org/packages/community/x86_64/stack/), so we will no longer be updating the AUR with new versions. See the [install/upgrade guide](http://docs.haskellstack.org/en/stable/install_and_upgrade/#arch-linux) for current download instructions. Major changes: - `stack init` and `solver` overhaul [#1583](https://github.com/commercialhaskell/stack/pull/1583) Other enhancements: - Disable locale/codepage hacks when GHC >=7.10.3 [#1552](https://github.com/commercialhaskell/stack/issues/1552) - Specify multiple images to build for `stack image container` [docs](http://docs.haskellstack.org/en/stable/yaml_configuration/#image) - Specify which executables to include in images for `stack image container` [docs](http://docs.haskellstack.org/en/stable/yaml_configuration/#image) - Docker: pass supplementary groups and umask into container - If git fetch fails wipe the directory and try again from scratch [#1418](https://github.com/commercialhaskell/stack/issues/1418) - Warn if newly installed executables won't be available on the PATH [#1362](https://github.com/commercialhaskell/stack/issues/1362) - stack.yaml: for `stack image container`, specify multiple images to generate, and which executables should be added to those images - GHCI: add interactive Main selection [#1068](https://github.com/commercialhaskell/stack/issues/1068) - Care less about the particular name of a GHCJS sdist folder [#1622](https://github.com/commercialhaskell/stack/issues/1622) - Unified Enable/disable help messaging [#1613](https://github.com/commercialhaskell/stack/issues/1613) Bug fixes: - Don't share precompiled packages between GHC/platform variants and Docker [#1551](https://github.com/commercialhaskell/stack/issues/1551) - Properly redownload corrupted downloads with the correct file size. [Mailing list discussion](https://groups.google.com/d/msg/haskell-stack/iVGDG5OHYxs/FjUrR5JsDQAJ) - Gracefully handle invalid paths in error/warning messages [#1561](https://github.com/commercialhaskell/stack/issues/1561) - Nix: select the correct GHC version corresponding to the snapshot even when an abstract resolver is passed via `--resolver` on the command-line. [#1641](https://github.com/commercialhaskell/stack/issues/1641) - Fix: Stack does not allow using an external package from ghci [#1557](https://github.com/commercialhaskell/stack/issues/1557) - Disable ambiguous global '--resolver' option for 'stack init' [#1531](https://github.com/commercialhaskell/stack/issues/1531) - Obey `--no-nix` flag - Fix: GHCJS Execute.hs: Non-exhaustive patterns in lambda [#1591](https://github.com/commercialhaskell/stack/issues/1591) - Send file-watch and sticky logger messages to stderr [#1302](https://github.com/commercialhaskell/stack/issues/1302) [#1635](https://github.com/commercialhaskell/stack/issues/1635) - Use globaldb path for querying Cabal version [#1647](https://github.com/commercialhaskell/stack/issues/1647) ## 1.0.0 Release notes: * We're calling this version 1.0.0 in preparation for Stackage LTS 4. Note, however, that this does not mean the code's API will be stable as this is primarily an end-user tool. Enhancements: * Added flag `--profile` flag: passed with `stack build`, it will enable profiling, and for `--bench` and `--test` it will generate a profiling report by passing `+RTS -p` to the executable(s). Great for using like `stack build --bench --profile` (remember that enabling profile will slow down your benchmarks by >4x). Run `stack build --bench` again to disable the profiling and get proper speeds * Added flag `--trace` flag: just like `--profile`, it enables profiling, but instead of generating a report for `--bench` and `--test`, prints out a stack trace on exception. Great for using like `stack build --test --trace` * Nix: all options can be overridden on command line [#1483](https://github.com/commercialhaskell/stack/issues/1483) * Nix: build environments (shells) are now pure by default. * Make verbosity silent by default in script interpreter mode [#1472](https://github.com/commercialhaskell/stack/issues/1472) * Show a message when resetting git commit fails [#1453](https://github.com/commercialhaskell/stack/issues/1453) * Improve Unicode handling in project/package names [#1337](https://github.com/commercialhaskell/stack/issues/1337) * Fix ambiguity between a stack command and a filename to execute (prefer `stack` subcommands) [#1471](https://github.com/commercialhaskell/stack/issues/1471) * Support multi line interpreter directive comments [#1394](https://github.com/commercialhaskell/stack/issues/1394) * Handle space separated pids in ghc-pkg dump (for GHC HEAD) [#1509](https://github.com/commercialhaskell/stack/issues/1509) * Add ghci --no-package-hiding option [#1517](https://github.com/commercialhaskell/stack/issues/1517) * `stack new` can download templates from URL [#1466](https://github.com/commercialhaskell/stack/issues/1466) Bug fixes: * Nix: stack exec options are passed properly to the stack sub process [#1538](https://github.com/commercialhaskell/stack/issues/1538) * Nix: specifying a shell-file works in any current working directory [#1547](https://github.com/commercialhaskell/stack/issues/1547) * Nix: use `--resolver` argument * Docker: fix missing image message and '--docker-auto-pull' * No HTML escaping for "stack new" template params [#1475](https://github.com/commercialhaskell/stack/issues/1475) * Set permissions for generated .ghci script [#1480](https://github.com/commercialhaskell/stack/issues/1480) * Restrict commands allowed in interpreter mode [#1504](https://github.com/commercialhaskell/stack/issues/1504) * stack ghci doesn't see preprocessed files for executables [#1347](https://github.com/commercialhaskell/stack/issues/1347) * All test suites run even when only one is requested [#1550](https://github.com/commercialhaskell/stack/pull/1550) * Edge cases in broken templates give odd errors [#1535](https://github.com/commercialhaskell/stack/issues/1535) * Fix test coverage bug on windows ## 0.1.10.1 Bug fixes: * `stack image container` did not actually build an image [#1473](https://github.com/commercialhaskell/stack/issues/1473) ## 0.1.10.0 Release notes: * The Stack home page is now at [haskellstack.org](http://haskellstack.org), which shows the documentation rendered by readthedocs.org. Note: this has necessitated some changes to the links in the documentation's markdown source code, so please check the links on the website before submitting a PR to fix them. * The locations of the [Ubuntu](http://docs.haskellstack.org/en/stable/install_and_upgrade/#ubuntu) and [Debian](http://docs.haskellstack.org/en/stable/install_and_upgrade/#debian) package repositories have changed to have correct URL semantics according to Debian's guidelines [#1378](https://github.com/commercialhaskell/stack/issues/1378). The old locations will continue to work for some months, but we suggest that you adjust your `/etc/apt/sources.list.d/fpco.list` to the new location to avoid future disruption. * [openSUSE and SUSE Linux Enterprise](http://docs.haskellstack.org/en/stable/install_and_upgrade/#suse) packages are now available, thanks to [@mimi1vx](https://github.com/mimi1vx). Note: there will be some lag before these pick up new versions, as they are based on Stackage LTS. Major changes: * Support for building inside a Nix-shell providing system dependencies [#1285](https://github.com/commercialhaskell/stack/pull/1285) * Add optional GPG signing on `stack upload --sign` or with `stack sig sign ...` Other enhancements: * Print latest applicable version of packages on conflicts [#508](https://github.com/commercialhaskell/stack/issues/508) * Support for packages located in Mercurial repositories [#1397](https://github.com/commercialhaskell/stack/issues/1397) * Only run benchmarks specified as build targets [#1412](https://github.com/commercialhaskell/stack/issues/1412) * Support git-style executable fall-through (`stack something` executes `stack-something` if present) [#1433](https://github.com/commercialhaskell/stack/issues/1433) * GHCi now loads intermediate dependencies [#584](https://github.com/commercialhaskell/stack/issues/584) * `--work-dir` option for overriding `.stack-work` [#1178](https://github.com/commercialhaskell/stack/issues/1178) * Support `detailed-0.9` tests [#1429](https://github.com/commercialhaskell/stack/issues/1429) * Docker: improved POSIX signal proxying to containers [#547](https://github.com/commercialhaskell/stack/issues/547) Bug fixes: * Show absolute paths in error messages in multi-package builds [#1348](https://github.com/commercialhaskell/stack/issues/1348) * Docker-built binaries and libraries in different path [#911](https://github.com/commercialhaskell/stack/issues/911) [#1367](https://github.com/commercialhaskell/stack/issues/1367) * Docker: `--resolver` argument didn't effect selected image tag * GHCi: Spaces in filepaths caused module loading issues [#1401](https://github.com/commercialhaskell/stack/issues/1401) * GHCi: cpp-options in cabal files weren't used [#1419](https://github.com/commercialhaskell/stack/issues/1419) * Benchmarks couldn't be run independently of each other [#1412](https://github.com/commercialhaskell/stack/issues/1412) * Send output of building setup to stderr [#1410](https://github.com/commercialhaskell/stack/issues/1410) ## 0.1.8.0 Major changes: * GHCJS can now be used with stackage snapshots via the new `compiler` field. * Windows installers are now available: [download them here](http://docs.haskellstack.org/en/stable/install_and_upgrade/#windows) [#613](https://github.com/commercialhaskell/stack/issues/613) * Docker integration works with non-FPComplete generated images [#531](https://github.com/commercialhaskell/stack/issues/531) Other enhancements: * Added an `allow-newer` config option [#922](https://github.com/commercialhaskell/stack/issues/922) [#770](https://github.com/commercialhaskell/stack/issues/770) * When a Hackage revision invalidates a build plan in a snapshot, trust the snapshot [#770](https://github.com/commercialhaskell/stack/issues/770) * Added a `stack config set resolver RESOLVER` command. Part of work on [#115](https://github.com/commercialhaskell/stack/issues/115) * `stack setup` can now install GHCJS on windows. See [#1145](https://github.com/commercialhaskell/stack/issues/1145) and [#749](https://github.com/commercialhaskell/stack/issues/749) * `stack hpc report` command added, which generates reports for HPC tix files * `stack ghci` now accepts all the flags accepted by `stack build`. See [#1186](https://github.com/commercialhaskell/stack/issues/1186) * `stack ghci` builds the project before launching GHCi. If the build fails, try to launch GHCi anyway. Use `stack ghci --no-build` option to disable [#1065](https://github.com/commercialhaskell/stack/issues/1065) * `stack ghci` now detects and warns about various circumstances where it is liable to fail. See [#1270](https://github.com/commercialhaskell/stack/issues/1270) * Added `require-docker-version` configuration option * Packages will now usually be built along with their tests and benchmarks. See [#1166](https://github.com/commercialhaskell/stack/issues/1166) * Relative `local-bin-path` paths will be relative to the project's root directory, not the current working directory. [#1340](https://github.com/commercialhaskell/stack/issues/1340) * `stack clean` now takes an optional `[PACKAGE]` argument for use in multi-package projects. See [#583](https://github.com/commercialhaskell/stack/issues/583) * Ignore cabal_macros.h as a dependency [#1195](https://github.com/commercialhaskell/stack/issues/1195) * Pad timestamps and show local time in --verbose output [#1226](https://github.com/commercialhaskell/stack/issues/1226) * GHCi: Import all modules after loading them [#995](https://github.com/commercialhaskell/stack/issues/995) * Add subcommand aliases: `repl` for `ghci`, and `runhaskell` for `runghc` [#1241](https://github.com/commercialhaskell/stack/issues/1241) * Add typo recommendations for unknown package identifiers [#158](https://github.com/commercialhaskell/stack/issues/158) * Add `stack path --local-hpc-root` option * Overhaul dependencies' haddocks copying [#1231](https://github.com/commercialhaskell/stack/issues/1231) * Support for extra-package-dbs in 'stack ghci' [#1229](https://github.com/commercialhaskell/stack/pull/1229) * `stack new` disallows package names with "words" consisting solely of numbers [#1336](https://github.com/commercialhaskell/stack/issues/1336) * `stack build --fast` turns off optimizations * Show progress while downloading package index [#1223](https://github.com/commercialhaskell/stack/issues/1223). Bug fixes: * Fix: Haddocks not copied for dependencies [#1105](https://github.com/commercialhaskell/stack/issues/1105) * Fix: Global options did not work consistently after subcommand [#519](https://github.com/commercialhaskell/stack/issues/519) * Fix: 'stack ghci' doesn't notice that a module got deleted [#1180](https://github.com/commercialhaskell/stack/issues/1180) * Rebuild when cabal file is changed * Fix: Paths in GHC warnings not canonicalized, nor those for packages in subdirectories or outside the project root [#1259](https://github.com/commercialhaskell/stack/issues/1259) * Fix: unlisted files in tests and benchmarks trigger extraneous second build [#838](https://github.com/commercialhaskell/stack/issues/838) ## 0.1.6.0 Major changes: * `stack setup` now supports building and booting GHCJS from source tarball. * On Windows, build directories no longer display "pretty" information (like x86_64-windows/Cabal-1.22.4.0), but rather a hash of that content. The reason is to avoid the 260 character path limitation on Windows. See [#1027](https://github.com/commercialhaskell/stack/pull/1027) * Rename config files and clarify their purposes [#969](https://github.com/commercialhaskell/stack/issues/969) * `~/.stack/stack.yaml` --> `~/.stack/config.yaml` * `~/.stack/global` --> `~/.stack/global-project` * `/etc/stack/config` --> `/etc/stack/config.yaml` * Old locations still supported, with deprecation warnings * New command "stack eval CODE", which evaluates to "stack exec ghc -- -e CODE". Other enhancements: * No longer install `git` on Windows [#1046](https://github.com/commercialhaskell/stack/issues/1046). You can still get this behavior by running the following yourself: `stack exec -- pacman -Sy --noconfirm git`. * Typing enter during --file-watch triggers a rebuild [#1023](https://github.com/commercialhaskell/stack/pull/1023) * Use Haddock's `--hyperlinked-source` (crosslinked source), if available [#1070](https://github.com/commercialhaskell/stack/pull/1070) * Use Stack-installed GHCs for `stack init --solver` [#1072](https://github.com/commercialhaskell/stack/issues/1072) * New experimental `stack query` command [#1087](https://github.com/commercialhaskell/stack/issues/1087) * By default, stack no longer rebuilds a package due to GHC options changes. This behavior can be tweaked with the `rebuild-ghc-options` setting. [#1089](https://github.com/commercialhaskell/stack/issues/1089) * By default, ghc-options are applied to all local packages, not just targets. This behavior can be tweaked with the `apply-ghc-options` setting. [#1089](https://github.com/commercialhaskell/stack/issues/1089) * Docker: download or override location of stack executable to re-run in container [#974](https://github.com/commercialhaskell/stack/issues/974) * Docker: when Docker Engine is remote, don't run containerized processes as host's UID/GID [#194](https://github.com/commercialhaskell/stack/issues/194) * Docker: `set-user` option to enable/disable running containerized processes as host's UID/GID [#194](https://github.com/commercialhaskell/stack/issues/194) * Custom Setup.hs files are now precompiled instead of interpreted. This should be a major performance win for certain edge cases (biggest example: [building Cabal itself](https://github.com/commercialhaskell/stack/issues/1041)) while being either neutral or a minor slowdown for more common cases. * `stack test --coverage` now also generates a unified coverage report for multiple test-suites / packages. In the unified report, test-suites can contribute to the coverage of other packages. Bug fixes: * Ignore stack-built executables named `ghc` [#1052](https://github.com/commercialhaskell/stack/issues/1052) * Fix quoting of output failed command line arguments * Mark executable-only packages as installed when copied from cache [#1043](https://github.com/commercialhaskell/stack/pull/1043) * Canonicalize temporary directory paths [#1047](https://github.com/commercialhaskell/stack/pull/1047) * Put code page fix inside the build function itself [#1066](https://github.com/commercialhaskell/stack/issues/1066) * Add `explicit-setup-deps` option [#1110](https://github.com/commercialhaskell/stack/issues/1110), and change the default to the old behavior of using any package in the global and snapshot database [#1025](https://github.com/commercialhaskell/stack/issues/1025) * Precompiled cache checks full package IDs on Cabal < 1.22 [#1103](https://github.com/commercialhaskell/stack/issues/1103) * Pass -package-id to ghci [#867](https://github.com/commercialhaskell/stack/issues/867) * Ignore global packages when copying precompiled packages [#1146](https://github.com/commercialhaskell/stack/issues/1146) ## 0.1.5.0 Major changes: * On Windows, we now use a full MSYS2 installation in place of the previous PortableGit. This gives you access to the pacman package manager for more easily installing libraries. * Support for custom GHC binary distributions [#530](https://github.com/commercialhaskell/stack/issues/530) * `ghc-variant` option in stack.yaml to specify the variant (also `--ghc-variant` command-line option) * `setup-info` in stack.yaml, to specify where to download custom binary distributions (also `--ghc-bindist` command-line option) * Note: On systems with libgmp4 (aka `libgmp.so.3`), such as CentOS 6, you may need to re-run `stack setup` due to the centos6 GHC bindist being treated like a variant * A new `--pvp-bounds` flag to the sdist and upload commands allows automatic adding of PVP upper and/or lower bounds to your dependencies Other enhancements: * Adapt to upcoming Cabal installed package identifier format change [#851](https://github.com/commercialhaskell/stack/issues/851) * `stack setup` takes a `--stack-setup-yaml` argument * `--file-watch` is more discerning about which files to rebuild for [#912](https://github.com/commercialhaskell/stack/issues/912) * `stack path` now supports `--global-pkg-db` and `--ghc-package-path` * `--reconfigure` flag [#914](https://github.com/commercialhaskell/stack/issues/914) [#946](https://github.com/commercialhaskell/stack/issues/946) * Cached data is written with a checksum of its structure [#889](https://github.com/commercialhaskell/stack/issues/889) * Fully removed `--optimizations` flag * Added `--cabal-verbose` flag * Added `--file-watch-poll` flag for polling instead of using filesystem events (useful for running tests in a Docker container while modifying code in the host environment. When code is injected into the container via a volume, the container won't propagate filesystem events). * Give a preemptive error message when `-prof` is given as a GHC option [#1015](https://github.com/commercialhaskell/stack/issues/1015) * Locking is now optional, and will be turned on by setting the `STACK_LOCK` environment variable to `true` [#950](https://github.com/commercialhaskell/stack/issues/950) * Create default stack.yaml with documentation comments and commented out options [#226](https://github.com/commercialhaskell/stack/issues/226) * Out of memory warning if Cabal exits with -9 [#947](https://github.com/commercialhaskell/stack/issues/947) Bug fixes: * Hacky workaround for optparse-applicative issue with `stack exec --help` [#806](https://github.com/commercialhaskell/stack/issues/806) * Build executables for local extra deps [#920](https://github.com/commercialhaskell/stack/issues/920) * copyFile can't handle directories [#942](https://github.com/commercialhaskell/stack/pull/942) * Support for spaces in Haddock interface files [fpco/minghc#85](https://github.com/fpco/minghc/issues/85) * Temporarily building against a "shadowing" local package? [#992](https://github.com/commercialhaskell/stack/issues/992) * Fix Setup.exe name for --upgrade-cabal on Windows [#1002](https://github.com/commercialhaskell/stack/issues/1002) * Unlisted dependencies no longer trigger extraneous second build [#838](https://github.com/commercialhaskell/stack/issues/838) ## 0.1.4.1 Fix stack's own Haddocks. No changes to functionality (only comments updated). ## 0.1.4.0 Major changes: * You now have more control over how GHC versions are matched, e.g. "use exactly this version," "use the specified minor version, but allow patches," or "use the given minor version or any later minor in the given major release." The default has switched from allowing newer later minor versions to a specific minor version allowing patches. For more information, see [#736](https://github.com/commercialhaskell/stack/issues/736) and [#784](https://github.com/commercialhaskell/stack/pull/784). * Support added for compiling with GHCJS * stack can now reuse prebuilt binaries between snapshots. That means that, if you build package foo in LTS-3.1, that binary version can be reused in LTS-3.2, assuming it uses the same dependencies and flags. [#878](https://github.com/commercialhaskell/stack/issues/878) Other enhancements: * Added the `--docker-env` argument, to set environment variables in Docker container. * Set locale environment variables to UTF-8 encoding for builds to avoid "commitBuffer: invalid argument" errors from GHC [#793](https://github.com/commercialhaskell/stack/issues/793) * Enable transliteration for encoding on stdout and stderr [#824](https://github.com/commercialhaskell/stack/issues/824) * By default, `stack upgrade` automatically installs GHC as necessary [#797](https://github.com/commercialhaskell/stack/issues/797) * Added the `ghc-options` field to stack.yaml [#796](https://github.com/commercialhaskell/stack/issues/796) * Added the `extra-path` field to stack.yaml * Code page changes on Windows only apply to the build command (and its synonyms), and can be controlled via a command line flag (still defaults to on) [#757](https://github.com/commercialhaskell/stack/issues/757) * Implicitly add packages to extra-deps when a flag for them is set [#807](https://github.com/commercialhaskell/stack/issues/807) * Use a precompiled Setup.hs for simple build types [#801](https://github.com/commercialhaskell/stack/issues/801) * Set --enable-tests and --enable-benchmarks optimistically [#805](https://github.com/commercialhaskell/stack/issues/805) * `--only-configure` option added [#820](https://github.com/commercialhaskell/stack/issues/820) * Check for duplicate local package names * Stop nagging people that call `stack test` [#845](https://github.com/commercialhaskell/stack/issues/845) * `--file-watch` will ignore files that are in your VCS boring/ignore files [#703](https://github.com/commercialhaskell/stack/issues/703) * Add `--numeric-version` option Bug fixes: * `stack init --solver` fails if `GHC_PACKAGE_PATH` is present [#860](https://github.com/commercialhaskell/stack/issues/860) * `stack solver` and `stack init --solver` check for test suite and benchmark dependencies [#862](https://github.com/commercialhaskell/stack/issues/862) * More intelligent logic for setting UTF-8 locale environment variables [#856](https://github.com/commercialhaskell/stack/issues/856) * Create missing directories for `stack sdist` * Don't ignore .cabal files with extra periods [#895](https://github.com/commercialhaskell/stack/issues/895) * Deprecate unused `--optimizations` flag * Truncated output on slow terminals [#413](https://github.com/commercialhaskell/stack/issues/413) ## 0.1.3.1 Bug fixes: * Ignore disabled executables [#763](https://github.com/commercialhaskell/stack/issues/763) ## 0.1.3.0 Major changes: * Detect when a module is compiled but not listed in the cabal file ([#32](https://github.com/commercialhaskell/stack/issues/32)) * A warning is displayed for any modules that should be added to `other-modules` in the .cabal file * These modules are taken into account when determining whether a package needs to be built * Respect TemplateHaskell addDependentFile dependency changes ([#105](https://github.com/commercialhaskell/stack/issues/105)) * TH dependent files are taken into account when determining whether a package needs to be built. * Overhauled target parsing, added `--test` and `--bench` options [#651](https://github.com/commercialhaskell/stack/issues/651) * For details, see [Build commands documentation](http://docs.haskellstack.org/en/stable/build_command/) Other enhancements: * Set the `HASKELL_DIST_DIR` environment variable [#524](https://github.com/commercialhaskell/stack/pull/524) * Track build status of tests and benchmarks [#525](https://github.com/commercialhaskell/stack/issues/525) * `--no-run-tests` [#517](https://github.com/commercialhaskell/stack/pull/517) * Targets outside of root dir don't build [#366](https://github.com/commercialhaskell/stack/issues/366) * Upper limit on number of flag combinations to test [#543](https://github.com/commercialhaskell/stack/issues/543) * Fuzzy matching support to give better error messages for close version numbers [#504](https://github.com/commercialhaskell/stack/issues/504) * `--local-bin-path` global option. Use to change where binaries get placed on a `--copy-bins` [#342](https://github.com/commercialhaskell/stack/issues/342) * Custom snapshots [#111](https://github.com/commercialhaskell/stack/issues/111) * --force-dirty flag: Force treating all local packages as having dirty files (useful for cases where stack can't detect a file change) * GHC error messages: display file paths as absolute instead of relative for better editor integration * Add the `--copy-bins` option [#569](https://github.com/commercialhaskell/stack/issues/569) * Give warnings on unexpected config keys [#48](https://github.com/commercialhaskell/stack/issues/48) * Remove Docker `pass-host` option * Don't require cabal-install to upload [#313](https://github.com/commercialhaskell/stack/issues/313) * Generate indexes for all deps and all installed snapshot packages [#143](https://github.com/commercialhaskell/stack/issues/143) * Provide `--resolver global` option [#645](https://github.com/commercialhaskell/stack/issues/645) * Also supports `--resolver nightly`, `--resolver lts`, and `--resolver lts-X` * Make `stack build --flag` error when flag or package is unknown [#617](https://github.com/commercialhaskell/stack/issues/617) * Preserve file permissions when unpacking sources [#666](https://github.com/commercialhaskell/stack/pull/666) * `stack build` etc work outside of a project * `list-dependencies` command [#638](https://github.com/commercialhaskell/stack/issues/638) * `--upgrade-cabal` option to `stack setup` [#174](https://github.com/commercialhaskell/stack/issues/174) * `--exec` option [#651](https://github.com/commercialhaskell/stack/issues/651) * `--only-dependencies` implemented correctly [#387](https://github.com/commercialhaskell/stack/issues/387) Bug fixes: * Extensions from the `other-extensions` field no longer enabled by default [#449](https://github.com/commercialhaskell/stack/issues/449) * Fix: haddock forces rebuild of empty packages [#452](https://github.com/commercialhaskell/stack/issues/452) * Don't copy over executables excluded by component selection [#605](https://github.com/commercialhaskell/stack/issues/605) * Fix: stack fails on Windows with git package in stack.yaml and no git binary on path [#712](https://github.com/commercialhaskell/stack/issues/712) * Fixed GHCi issue: Specifying explicit package versions (#678) * Fixed GHCi issue: Specifying -odir and -hidir as .stack-work/odir (#529) * Fixed GHCi issue: Specifying A instead of A.ext for modules (#498) ## 0.1.2.0 * Add `--prune` flag to `stack dot` [#487](https://github.com/commercialhaskell/stack/issues/487) * Add `--[no-]external`,`--[no-]include-base` flags to `stack dot` [#437](https://github.com/commercialhaskell/stack/issues/437) * Add `--ignore-subdirs` flag to init command [#435](https://github.com/commercialhaskell/stack/pull/435) * Handle attempt to use non-existing resolver [#436](https://github.com/commercialhaskell/stack/pull/436) * Add `--force` flag to `init` command * exec style commands accept the `--package` option (see [Reddit discussion](http://www.reddit.com/r/haskell/comments/3bd66h/stack_runghc_turtle_as_haskell_script_solution/)) * `stack upload` without arguments doesn't do anything [#439](https://github.com/commercialhaskell/stack/issues/439) * Print latest version of packages on conflicts [#450](https://github.com/commercialhaskell/stack/issues/450) * Flag to avoid rerunning tests that haven't changed [#451](https://github.com/commercialhaskell/stack/issues/451) * stack can act as a script interpreter (see [Script interpreter] (https://github.com/commercialhaskell/stack/wiki/Script-interpreter) and [Reddit discussion](http://www.reddit.com/r/haskell/comments/3bd66h/stack_runghc_turtle_as_haskell_script_solution/)) * Add the __`--file-watch`__ flag to auto-rebuild on file changes [#113](https://github.com/commercialhaskell/stack/issues/113) * Rename `stack docker exec` to `stack exec --plain` * Add the `--skip-msys` flag [#377](https://github.com/commercialhaskell/stack/issues/377) * `--keep-going`, turned on by default for tests and benchmarks [#478](https://github.com/commercialhaskell/stack/issues/478) * `concurrent-tests: BOOL` [#492](https://github.com/commercialhaskell/stack/issues/492) * Use hashes to check file dirtiness [#502](https://github.com/commercialhaskell/stack/issues/502) * Install correct GHC build on systems with libgmp.so.3 [#465](https://github.com/commercialhaskell/stack/issues/465) * `stack upgrade` checks version before upgrading [#447](https://github.com/commercialhaskell/stack/issues/447) ## 0.1.1.0 * Remove GHC uncompressed tar file after installation [#376](https://github.com/commercialhaskell/stack/issues/376) * Put stackage snapshots JSON on S3 [#380](https://github.com/commercialhaskell/stack/issues/380) * Specifying flags for multiple packages [#335](https://github.com/commercialhaskell/stack/issues/335) * single test suite failure should show entire log [#388](https://github.com/commercialhaskell/stack/issues/388) * valid-wanted is a confusing option name [#386](https://github.com/commercialhaskell/stack/issues/386) * stack init in multi-package project should use local packages for dependency checking [#384](https://github.com/commercialhaskell/stack/issues/384) * Display information on why a snapshot was rejected [#381](https://github.com/commercialhaskell/stack/issues/381) * Give a reason for unregistering packages [#389](https://github.com/commercialhaskell/stack/issues/389) * `stack exec` accepts the `--no-ghc-package-path` parameter * Don't require build plan to upload [#400](https://github.com/commercialhaskell/stack/issues/400) * Specifying test components only builds/runs those tests [#398](https://github.com/commercialhaskell/stack/issues/398) * `STACK_EXE` environment variable * Add the `stack dot` command * `stack upgrade` added [#237](https://github.com/commercialhaskell/stack/issues/237) * `--stack-yaml` command line flag [#378](https://github.com/commercialhaskell/stack/issues/378) * `--skip-ghc-check` command line flag [#423](https://github.com/commercialhaskell/stack/issues/423) Bug fixes: * Haddock links to global packages no longer broken on Windows [#375](https://github.com/commercialhaskell/stack/issues/375) * Make flags case-insensitive [#397](https://github.com/commercialhaskell/stack/issues/397) * Mark packages uninstalled before rebuilding [#365](https://github.com/commercialhaskell/stack/issues/365) ## 0.1.0.0 * Fall back to cabal dependency solver when a snapshot can't be found * Basic implementation of `stack new` [#137](https://github.com/commercialhaskell/stack/issues/137) * `stack solver` command [#364](https://github.com/commercialhaskell/stack/issues/364) * `stack path` command [#95](https://github.com/commercialhaskell/stack/issues/95) * Haddocks [#143](https://github.com/commercialhaskell/stack/issues/143): * Build for dependencies * Use relative links * Generate module contents and index for all packages in project ## 0.0.3 * `--prefetch` [#297](https://github.com/commercialhaskell/stack/issues/297) * `upload` command ported from stackage-upload [#225](https://github.com/commercialhaskell/stack/issues/225) * `--only-snapshot` [#310](https://github.com/commercialhaskell/stack/issues/310) * `--resolver` [#224](https://github.com/commercialhaskell/stack/issues/224) * `stack init` [#253](https://github.com/commercialhaskell/stack/issues/253) * `--extra-include-dirs` and `--extra-lib-dirs` [#333](https://github.com/commercialhaskell/stack/issues/333) * Specify intra-package target [#201](https://github.com/commercialhaskell/stack/issues/201) ## 0.0.2 * Fix some Windows specific bugs [#216](https://github.com/commercialhaskell/stack/issues/216) * Improve output for package index updates [#227](https://github.com/commercialhaskell/stack/issues/227) * Automatically update indices as necessary [#227](https://github.com/commercialhaskell/stack/issues/227) * --verbose flag [#217](https://github.com/commercialhaskell/stack/issues/217) * Remove packages (HTTPS and Git) [#199](https://github.com/commercialhaskell/stack/issues/199) * Config values for system-ghc and install-ghc * Merge `stack deps` functionality into `stack build` * `install` command [#153](https://github.com/commercialhaskell/stack/issues/153) and [#272](https://github.com/commercialhaskell/stack/issues/272) * overriding architecture value (useful to force 64-bit GHC on Windows, for example) * Overhauled test running (allows cycles, avoids unnecessary recompilation, etc) ## 0.0.1 * First public release, beta quality stack-1.9.3.1/README.md0000644000000000000000000000171613455666157012464 0ustar0000000000000000## The Haskell Tool Stack [![Build Status](https://travis-ci.org/commercialhaskell/stack.svg?branch=master)](https://travis-ci.org/commercialhaskell/stack) [![Windows build status](https://ci.appveyor.com/api/projects/status/c1c7uvmw6x1dupcl?svg=true)](https://ci.appveyor.com/project/snoyberg/stack) [![Release](https://img.shields.io/github/release/commercialhaskell/stack.svg)](https://github.com/commercialhaskell/stack/releases) [![Join the chat at https://gitter.im/commercialhaskell/stack](https://badges.gitter.im/commercialhaskell/stack.svg)](https://gitter.im/commercialhaskell/stack?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge) Stack is a cross-platform program for developing Haskell projects. It is intended for Haskellers both new and experienced. See [haskellstack.org](http://haskellstack.org) or the [doc](./doc) directory for more information. ### Subsystem maintainers * GHCJS - [Matchwood](https://github.com/matchwood)stack-1.9.3.1/doc/architecture.md0000644000000000000000000002160513455666157014755 0ustar0000000000000000
# Architecture ## Terminology * Package identifier: a package name and version, e.g. text-1.2.1.0 * GhcPkgId: a package identifier plus the unique hash for the generated binary, e.g. text-1.2.1.0-bb83023b42179dd898ebe815ada112c2 * Package index: a collection of packages available for download. This is a combination of an index containing all of the .cabal files (either a tarball downloaded via HTTP(S) or a Git repository) and some way to download package tarballs. * By default, stack uses a single package index (the Github/S3 mirrors of Hackage), but supports customization and adding more than one index * Package database: a collection of metadata about built libraries * Install root: a destination for installing packages into. Contains a bin path (for generated executables), lib (for the compiled libraries), pkgdb (for the package database), and a few other things * Snapshot: an LTS Haskell or Stackage Nightly, which gives information on a complete set of packages. This contains a lot of metadata, but importantly it can be converted into a mini build plan... * Mini build plan: a collection of package identifiers and their build flags that are known to build together * Resolver: the means by which stack resolves dependencies for your packages. The two currently supported options are snapshot (using LTS or Nightly), and GHC (which installs no extra dependencies). Others may be added in the future (such as a SAT-based dependency solver). These packages are always taken from a package index * extra-deps: additional packages to be taken from the package index for dependencies. This list will *shadow* packages provided by the resolver * Local packages: source code actually present on your file system, and referred to by the `packages` field in your stack.yaml file. Each local package has exactly one .cabal file * Project: a stack.yaml config file and all of the local packages it refers to. ## Databases Every build uses three distinct install roots, which means three separate package databases and bin paths. These are: * Global: the packages that ship with GHC. We never install anything into this database * Snapshot: a database shared by all projects using the same snapshot. Packages installed in this database must use the exact same dependencies and build flags as specified in the snapshot, and cannot be affected by user flags, ensuring that one project cannot corrupt another. There are two caveats to this: * If different projects use different package indices, then their definitions of what package foo-1.2.3 are may be different, in which case they *can* corrupt each other's shared databases. This is warned about in the FAQ * Turning on profiling may cause a package to be recompiled, which will result in a different GhcPkgId * Local: extra-deps, local packages, and snapshot packages which depend on them (more on that in shadowing) ## Building ### Shadowing Every project must have precisely one version of a package. If one of your local packages or extra dependencies conflicts with a package in the snapshot, the local/extradep *shadows* the snapshot version. The way this works is: * The package is removed from the list of packages in the snapshot * Any package that depends on that package (directly or indirectly) is moved from the snapshot to extra-deps, so that it is available to your packages as dependencies. * Note that there is no longer any guarantee that this package will build, since you're using an untested dependency After shadowing, you end up with what is called internally a `SourceMap`, which is `Map PackageName PackageSource`, where a `PackageSource` can be either a local package, or a package taken from a package index (specified as a version number and the build flags). ### Installed packages Once you have a `SourceMap`, you can inspect your three available databases and decide which of the installed packages you wish to use from them. We move from the global, to snapshot, and finally local, with the following rules: * If we require profiling, and the library does not provide profiling, do not use it * If the package is in the `SourceMap`, but belongs to a difference database, or has a different version, do not use it * If after the above two steps, any of the dependencies are unavailable, do not use it * Otherwise: include the package in the list of installed packages We do something similar for executables, but maintain our own database of installed executables, since GHC does not track them for us. ### Plan construction When running a build, we know which packages we want installed (inventively called "wanteds"), which packages are available to install, and which are already installed. In plan construction, we put this information together to decide which packages must be built. The code in Stack.Build.ConstructPlan is authoritative on this and should be consulted. The basic idea though is: * If any of the dependencies have changed, reconfigure and rebuild * If a local package has any files changed, rebuild (but don't bother reconfiguring) * If a local package is wanted and we're running tests or benchmarks, run the test or benchmark even if the code and dependencies haven't changed ### Plan execution Once we have the plan, execution is a relatively simple process of calling `runghc Setup.hs` in the correct order with the correct parameters. See Stack.Build.Execute for more information. ## Configuration stack has two layers of configuration: project and non-project. All of these are stored in stack.yaml files, but the former has extra fields (resolver, packages, extra-deps, and flags). The latter can be monoidally combined so that a system config file provides defaults, which a user can override with `~/.stack/config.yaml`, and a project can further customize. In addition, environment variables STACK\_ROOT and STACK\_YAML can be used to tweak where stack gets its configuration from. stack follows a simple algorithm for finding your project configuration file: start in the current directory, and keep going to the parent until it finds a `stack.yaml`. When using `stack ghc` or `stack exec` as mentioned above, you'll sometimes want to override that behavior and point to a specific project in order to use its databases and bin directories. To do so, simply set the `STACK_YAML` environment variable to point to the relevant `stack.yaml` file. ## Snapshot auto-detection When you run `stack build` with no stack.yaml, it will create a basic configuration with a single package (the current directory) and an auto-detected snapshot. The algorithm it uses for selecting this snapshot is: * Try the latest two LTS major versions at their most recent minor version release, and the most recent Stackage Nightly. For example, at the time of writing, this would be lts-2.10, lts-1.15, and nightly-2015-05-26 * For each of these, test the version bounds in the package's .cabal file to see if they are compatible with the snapshot, choosing the first one that matches * If no snapshot matches, uses the most recent LTS snapshot, even though it will not compile If you end up in the no compatible snapshot case, you typically have three options to fix things: * Manually specify a different snapshot that you know to be compatible. If you can do that, great, but typically if the auto-detection fails, it means that there's no compatible snapshot * Modify version bounds in your .cabal file to be compatible with the selected snapshot * Add `extra-deps` to your stack.yaml file to fix compatibility problems Remember that running `stack build` will give you information on why your build cannot occur, which should help guide you through the steps necessary for the second and third option above. Also, note that those options can be mixed-and-matched, e.g. you may decide to relax some version bounds in your .cabal file, while also adding some extra-deps. ## Explicit breakage As mentioned above, updating your package indices will not cause stack to invalidate any existing package databases. That's because stack is always explicit about build plans, via: 1. the selected snapshot 2. the extra-deps 3. local packages The only way to change a plan for packages to be installed is by modifying one of the above. This means that breakage of a set of installed packages is an *explicit* and *contained* activity. Specifically, you get the following guarantees: * Since snapshots are immutable, the snapshot package database will not be invalidated by any action. If you change the snapshot you're using, however, you may need to build those packages from scratch. * If you modify your extra-deps, stack may need to unregister and reinstall them. * Any changes to your local packages trigger a rebuild of that package and its dependencies. stack-1.9.3.1/doc/build_command.md0000644000000000000000000002434413455666157015073 0ustar0000000000000000
# Build command ## Overview The primary command you use in stack is build. This page describes the build command's interface. The goal of the interface is to do the right thing for simple input, and allow a lot of flexibility for more complicated goals. See the [build command section of the user guide](GUIDE.md#the-build-command) for info beyond the CLI aspects of the build command. ## Synonyms One potential point of confusion is the synonym commands for `build`. These are provided to match commonly expected command line interfaces, and to make common workflows shorter. The important thing to note is that all of these are just the `build` command in disguise. Each of these commands are called out as synonyms in the `--help` output. These commands are: * `stack test` is the same as `stack build --test` * `stack bench` is the same as `stack build --bench` * `stack haddock` is the same as `stack build --haddock` * `stack install` is the same as `stack build --copy-bins` The advantage of the synonym commands is that they're convenient and short. The advantage of the options is that they compose. For example, `stack build --test --copy-bins` will build libraries, executables, and test suites, run the test suites, and then copy the executables to your local bin path (more on this below). ## Components Components are a subtle yet important point to how build operates under the surface. Every cabal package is made up of one or more components. It can have 0 or 1 libraries, and then 0 or more of executable, test, and benchmark components. stack allows you to call out a specific component to be built, e.g. `stack build mypackage:test:mytests` will build the `mytests` component of the `mypackage` package. `mytests` must be a test suite component. We'll get into the details of the target syntax for how to select components in the next section. In this section, the important point is: whenever you target a test suite or a benchmark, it's built __and also run__, unless you explicitly disable running via `--no-run-tests` or `--no-run-benchmarks`. Case in point: the previous command will in fact build the `mytests` test suite *and* run it, even though you haven't used the `stack test` command or the `--test` option. (We'll get to what exactly `--test` does below.) This gives you a lot of flexibility in choosing what you want stack to do. You can run a single test component from a package, run a test component from one package and a benchmark from another package, etc. One final note on components: you can only control components for local packages, not dependencies. With dependencies, stack will *always* build the library (if present) and all executables, and ignore test suites and benchmarks. If you want more control over a package, you must add it to your `packages` setting in your stack.yaml file. ## Target syntax In addition to a number of options (like the aforementioned `--test`), `stack build` takes a list of zero or more *targets* to be built. There are a number of different syntaxes supported for this list: * *package*, e.g. `stack build foobar`, is the most commonly used target. It will try to find the package in the following locations: local packages, extra dependencies, snapshots, and package index (e.g. Hackage). If it's found in the package index, then the latest version of that package from the index is implicitly added to your extra dependencies. This is where the `--test` and `--bench` flags come into play. If the package is a local package, then all of the test suite and benchmark components are selected to be built, respectively. In any event, the library and executable components are also selected to be built. * *package identifier*, e.g. `stack build foobar-1.2.3`, is usually used to include specific package versions from the index. If the version selected conflicts with an existing local package or extra dep, then stack fails with an error. Otherwise, this is the same as calling `stack build foobar`, except instead of using the latest version from the index, the version specified is used. * *component*. Instead of referring to an entire package and letting stack decide which components to build, you select individual components from inside a package. This can be done for more fine-grained control over which test suites to run, or to have a faster compilation cycle. There are multiple ways to refer to a specific component (provided for convenience): * `packagename:comptype:compname` is the most explicit. The available comptypes are `exe`, `test`, and `bench`. * Side note: When any `exe` component is specified, all of the package's executable components will be built. This is due to limitations in all currently released versions of Cabal. See [issue#1046](https://github.com/commercialhaskell/stack/issues/1406) * `packagename:compname` allows you to leave off the component type, as that will (almost?) always be redundant with the component name. For example, `stack build mypackage:mytestsuite`. * `:compname` is a useful shortcut, saying "find the component in all of the local packages." This will result in an error if multiple packages have a component with the same name. To continue the above example, `stack build :mytestsuite`. * Side note: the commonly requested `run` command is not available because it's a simple combination of `stack build :exename && stack exec exename` * *directory*, e.g. `stack build foo/bar`, will find all local packages that exist in the given directory hierarchy and then follow the same procedure as passing in package names as mentioned above. There's an important caveat here: if your directory name is parsed as one of the above target types, it will be treated as that. Explicitly starting your target with `./` can be a good way to avoid that, e.g. `stack build ./foo` Finally: if you provide no targets (e.g., running `stack build`), stack will implicitly pass in all of your local packages. If you only want to target packages in the current directory or deeper, you can pass in `.`, e.g. `stack build .`. To get a list of the available targets in your project, use `stack ide targets`. ## Controlling what gets built Stack will automatically build the necessary dependencies. See the [build command section of the user guide](GUIDE.md#the-build-command) for details of how these dependencies get specified. In addition to specifying targets, you can also control what gets built with the following flags: * `--haddock`, to build documentation. This may cause a lot of packages to get re-built, so that the documentation links work. * `--force-dirty`, to force rebuild of packages even when it doesn't seem necessary based on file dirtiness. * `--reconfigure`, to force reconfiguration even when it doesn't seem necessary based on file dirtiness. This is sometimes useful with custom Setup.hs files, in particular when they depend on external data files. * `--dry-run`, to build nothing and output information about the build plan. * `--only-dependencies`, to skip building the targets. * `--only-snapshot`, to only build snapshot dependencies, which are cached and shared with other projects. * `--keep-going`, to continue building packages even after some build step fails. The packages which depend upon the failed build won't get built. * `--skip`, to skip building components of a local package. It allows you to skip test suites and benchmark without specifying other components (e.g. `stack test --skip long-test-suite` will run the tests without the `long-test-suite` test suite). Be aware that skipping executables won't work the first time the package is built due to [an issue in cabal](https://github.com/commercialhaskell/stack/issues/3229). This option can be specified multiple times to skip multiple components. ## Flags There are a number of other flags accepted by `stack build`. Instead of listing all of them, please use `stack build --help`. Some particularly convenient ones worth mentioning here since they compose well with the rest of the build system as described: * `--file-watch` will rebuild your project every time a file changes * `--exec "cmd [args]"` will run a command after a successful build To come back to the composable approach described above, consider this final example (which uses the [wai repository](https://github.com/yesodweb/wai/)): ``` stack build --file-watch --test --copy-bins --haddock wai-extra :warp warp:doctest --exec 'echo Yay, it worked!' ``` This command will: * Start stack up in file watch mode, waiting for files in your project to change. When first starting, and each time a file changes, it will do all of the following. * Build the wai-extra package and its test suites * Build the `warp` executable * Build the warp package's doctest component (which, as you may guess, is a test site) * Run all of the wai-extra package's test suite components and the doctest test suite component * If all of that succeeds: * Copy generated executables to the local bin path * Run the command `echo Yay, it worked!` ## Build output When building a single target package (e.g., `stack build` in a project with only one package, or `stack build package-name` in a multi-package project), the build output from GHC will be hidden for building all dependencies, and will be displayed for the one target package. By default, when building multiple target packages, the output from these will end up in a log file instead of on the console unless it contains errors or warnings, to avoid problems of interleaved output and decrease console noise. If you would like to see this content instead, you can use the `--dump-logs` command line option, or add `dump-logs: all` to your `stack.yaml` file. Alternatively, starting with Stack 1.8, you can pass `--interleaved-output` to see output of all packages being built scroll by in a streaming fashion. The output from each package built will be prefixed by the package name, e.g. `mtl> Building ...`. Note that, unlike the default output, this will include the output from dependencies being built, not just targets. stack-1.9.3.1/doc/ChangeLog.md0000644000000000000000000032467113455702176014123 0ustar0000000000000000# Changelog ## v1.9.3.1 Hackage-only release with no user facing changes (added compatibility with `rio-0.1.9.2`). ## v1.9.3 Bug fixes: * Stack can now be compiled again inside a directory that does not contain a `.git` directory, see [#4364](https://github.com/commercialhaskell/stack/issues/4364#issuecomment-431600841) * Handle a change in GHC's hi-dump format around `addDependentFile`, which now includes a hash. See [yesodweb/yesod#1551](https://github.com/yesodweb/yesod/issues/1551) * Allow variables to appear in template file names. ## v1.9.1.1 Hackage-only release with no user facing changes. * Stack can now be compiled again inside a directory that does not contain a `.git` directory, see [#4364](https://github.com/commercialhaskell/stack/issues/4364#issuecomment-431600841) ## v1.9.1 Release notes: * Statically linked Linux bindists are back again, thanks to [@nh2](https://github.com/nh2). * We will be deleting the Ubuntu, Debian, CentOS, Fedora, and Arch package repos from `download.fpcomplete.com` soon. These have been deprecated for over a year and have not received new releases, but were left in place for compatibility with older scripts. Major changes: * Upgrade to Cabal 2.4 * Note that, in this process, the behavior of file globbing has been modified to match that of Cabal. In particular, this means that for Cabal spec versions less than 2.4, `*.txt` will match `foo.txt`, but not `foo.2.txt`. * `GHCJS` support is being downgraded to 'experimental'. A warning notifying the user of the experimental status of `GHCJS` will be displayed. Behavior changes: * `ghc-options` from `stack.yaml` are now appended to `ghc-options` from `config.yaml`, whereas before they would be replaced. * `stack build` will now announce when sublibraries of a package are being build, in the same way executables, tests, benchmarks and libraries are announced * `stack sdist` will now announce the destination of the generated tarball, regardless of whether or not it passed the sanity checks * The `--upgrade-cabal` option to `stack setup` has been deprecated. This feature no longer works with GHC 8.2 and later. Furthermore, the reason for this flag originally being implemented was drastically lessened once Stack started using the snapshot's `Cabal` library for custom setups. See: [#4070](https://github.com/commercialhaskell/stack/issues/4070). * With the new namespaced template feature, `stack templates` is no longer able to meaningfully display a list of all templates available. Instead, the command will download and display a [help file](https://github.com/commercialhaskell/stack-templates/blob/master/STACK_HELP.md) with more information on how to discover templates. See: [#4039](https://github.com/commercialhaskell/stack/issues/4039) * Build tools are now handled in a similar way to `cabal-install`. In particular, for legacy `build-tools` fields, we use a hard-coded list of build tools in place of looking up build tool packages in a tool map. This both brings Stack's behavior closer into line with `cabal-install`, avoids some bugs, and opens up some possible optimizations/laziness. See: [#4125](https://github.com/commercialhaskell/stack/issues/4125). * Mustache templating is not applied to large files (over 50kb) to avoid performance degredation. See: [#4133](https://github.com/commercialhaskell/stack/issues/4133). * `stack upload` signs the package by default, as documented. `--no-signature` turns the signing off. [#3739](https://github.com/commercialhaskell/stack/issues/3739) * In case there is a network connectivity issue while trying to download a template, stack will check whether that template had been downloaded before. In that case, the cached version will be used. See [#3850](https://github.com/commercialhaskell/stack/issues/3850). Other enhancements: * On Windows before Windows 10, --color=never is the default on terminals that can support ANSI color codes in output only by emulation * On Windows, recognise a 'mintty' (false) terminal as a terminal, by default * `stack build` issues a warning when `base` is explicitly listed in `extra-deps` of `stack.yaml` * `stack build` suggests trying another GHC version should the build plan end up requiring unattainable `base` version. * A new sub command `run` has been introduced to build and run a specified executable similar to `cabal run`. If no executable is provided as the first argument, it defaults to the first available executable in the project. * `stack build` missing dependency suggestions (on failure to construct a valid build plan because of missing deps) are now printed with their latest cabal file revision hash. See [#4068](https://github.com/commercialhaskell/stack/pull/4068). * Added new `--tar-dir` option to `stack sdist`, that allows to copy the resulting tarball to the specified directory. * Introduced the `--interleaved-output` command line option and `build.interleaved-output` config value which causes multiple concurrent builds to dump to stderr at the same time with a `packagename> ` prefix. See [#3225](https://github.com/commercialhaskell/stack/issues/3225). * The default retry strategy has changed to exponential backoff. This should help with [#3510](https://github.com/commercialhaskell/stack/issues/3510). * `stack new` now allows template names of the form `username/foo` to download from a user other than `commercialstack` on Github, and can be prefixed with the service `github:`, `gitlab:`, or `bitbucket:`. [#4039](https://github.com/commercialhaskell/stack/issues/4039) * Switch to `githash` to include some unmerged bugfixes in `gitrev` Suggestion to add `'allow-newer': true` now shows path to user config file where this flag should be put into [#3685](https://github.com/commercialhaskell/stack/issues/3685) * `stack ghci` now asks which main target to load before doing the build, rather than after * Bump to hpack 0.29.0 * With GHC 8.4 and later, Haddock is given the `--quickjump` flag. * It is possible to specify the Hackage base URL to upload packages to, instead of the default of `https://hackage.haskell.org/`, by using `hackage-base-url` configuration option. * When using Nix, if a specific minor version of GHC is not requested, the latest minor version in the given major branch will be used automatically. Bug fixes: * `stack ghci` now does not invalidate `.o` files on repeated runs, meaning any modules compiled with `-fobject-code` will be cached between ghci runs. See [#4038](https://github.com/commercialhaskell/stack/pull/4038). * `~/.stack/config.yaml` and `stack.yaml` terminating by newline * The previous released caused a regression where some `stderr` from the `ghc-pkg` command showed up in the terminal. This output is now silenced. * A regression in recompilation checking introduced in v1.7.1 has been fixed. See [#4001](https://github.com/commercialhaskell/stack/issues/4001) * `stack ghci` on a package with internal libraries was erroneously looking for a wrong package corresponding to the internal library and failing to load any module. This has been fixed now and changes to the code in the library and the sublibrary are properly tracked. See [#3926](https://github.com/commercialhaskell/stack/issues/3926). * For packages with internal libraries not depended upon, `stack build` used to fail the build process since the internal library was not built but it was tried to be registered. This is now fixed by always building internal libraries. See [#3996](https://github.com/commercialhaskell/stack/issues/3996). * `--no-nix` was not respected under NixOS * Fix a regression which might use a lot of RAM. See [#4027](https://github.com/commercialhaskell/stack/issues/4027). * Order of commandline arguments does not matter anymore. See [#3959](https://github.com/commercialhaskell/stack/issues/3959) * When prompting users about saving their Hackage credentials on upload, flush to stdout before waiting for the response so the prompt actually displays. Also fixes a similar issue with ghci target selection prompt. * If `cabal` is not on PATH, running `stack solver` now prompts the user to run `stack install cabal-install` * `stack build` now succeeds in building packages which contain sublibraries which are dependencies of executables, tests or benchmarks but not of the main library. See [#3787](https://github.com/commercialhaskell/stack/issues/3787). * Sublibraries are now properly considered for coverage reports when the test suite depends on the internal library. Before, stack was erroring when trying to generate the coverage report, see [#4105](https://github.com/commercialhaskell/stack/issues/4105). * Sublibraries are now added to the precompiled cache and recovered from there when the snapshot gets updated. Previously, updating the snapshot when there was a package with a sublibrary in the snapshot resulted in broken builds. This is now fixed, see [#4071](https://github.com/commercialhaskell/stack/issues/4071). * [#4114](https://github.com/commercialhaskell/stack/issues/4114) Stack pretty prints error messages with proper `error` logging level instead of `warning` now. This also fixes self-executing scripts not piping plan construction errors from runhaskell to terminal (issue [#3942](https://github.com/commercialhaskell/stack/issues/3942)). * Fix invalid "While building Setup.hs" when Cabal calls fail. See: [#3934](https://github.com/commercialhaskell/stack/issues/3934) * `stack upload` signs the package by default, as documented. `--no-signature` turns the signing off. [#3739](https://github.com/commercialhaskell/stack/issues/3739) ## v1.7.1 Release notes: * aarch64 (64-bit ARM) bindists are now available for the first time. * Statically linked Linux bindists are no longer available, due to difficulty with GHC 8.2.2 on Alpine Linux. * 32-bit Linux GMP4 bindists for CentOS 6 are no longer available, since GHC 8.2.2 is no longer being built for that platform. Major changes: * Upgrade from Cabal 2.0 to Cabal 2.2 Behavior changes: * `stack setup` no longer uses different GHC configure options on Linux distributions that use GCC with PIE enabled by default. GHC detects this itself since ghc-8.0.2, and Stack's attempted workaround for older versions caused more problems than it solved. * `stack new` no longer initializes a project if the project template contains a stack.yaml file. Other enhancements: * A new sub command `ls` has been introduced to stack to view local and remote snapshots present in the system. Use `stack ls snapshots --help` to get more details about it. * `list-dependencies` has been deprecated. The functionality has to accessed through the new `ls dependencies` interface. See [#3669](https://github.com/commercialhaskell/stack/issues/3669) for details. * Specify User-Agent HTTP request header on every HTTP request. See [#3628](https://github.com/commercialhaskell/stack/issues/3628) for details. * `stack setup` looks for GHC bindists and installations by any OS key that is compatible (rather than only checking a single one). This is relevant on Linux where different distributions may have different combinations of libtinfo 5/6, ncurses 5/6, and gmp 4/5, and will allow simpifying the setup-info metadata YAML for future GHC releases. * The build progress bar reports names of packages currently building. * `stack setup --verbose` causes verbose output of GHC configure process. See [#3716](https://github.com/commercialhaskell/stack/issues/3716) * Improve the error message when an `extra-dep` from a path or git reference can't be found See [#3808](https://github.com/commercialhaskell/stack/pull/3808) * Nix integration is now disabled on windows even if explicitly enabled, since it isn't supported. See [#3600](https://github.com/commercialhaskell/stack/issues/3600) * `stack build` now supports a new flag `--keep-tmp-files` to retain intermediate files and directories for the purpose of debugging. It is best used with ghc's equivalent flag, i.e. `stack build --keep-tmp-files --ghc-options=-keep-tmp-files`. See [#3857](https://github.com/commercialhaskell/stack/issues/3857) * Improved error messages for snapshot parse exceptions * `stack unpack` now supports a `--to /target/directory` option to specify where to unpack the package into * `stack hoogle` now supports a new flag `--server` that launches local Hoogle server on port 8080. See [#2310](https://github.com/commercialhaskell/stack/issues/2310) Bug fixes: * The script interpreter's implicit file arguments are now passed before other arguments. See [#3658](https://github.com/commercialhaskell/stack/issues/3658). In particular, this makes it possible to pass `-- +RTS ... -RTS` to specify RTS arguments used when running the script. * Don't ignore the template `year` parameter in config files, and clarify the surrounding documentation. See [#2275](https://github.com/commercialhaskell/stack/issues/2275). * Benchmarks used to be run concurrently with other benchmarks and build steps. This is non-ideal because CPU usage of other processes may interfere with benchmarks. It also prevented benchmark output from being displayed by default. This is now fixed. See [#3663](https://github.com/commercialhaskell/stack/issues/3663). * `stack ghci` now allows loading multiple packages with the same module name, as long as they have the same filepath. See [#3776](https://github.com/commercialhaskell/stack/pull/3776). * `stack ghci` no longer always adds a dependency on `base`. It is now only added when there are no local targets. This allows it to be to load code that uses replacements for `base`. See [#3589](https://github.com/commercialhaskell/stack/issues/3589#issuecomment) * `stack ghci` now uses correct paths for autogen files with [#3791](https://github.com/commercialhaskell/stack/issues/3791) * When a package contained sublibraries, stack was always recompiling the package. This has been fixed now, no recompilation is being done because of sublibraries. See [#3899](https://github.com/commercialhaskell/stack/issues/3899). * The `get-stack.sh` install script now matches manual instructions when it comes to Debian/Fedora/CentOS install dependencies. * Compile Cabal-simple with gmp when using Nix. See [#2944](https://github.com/commercialhaskell/stack/issues/2944) * `stack ghci` now replaces the stack process with ghci. This improves signal handling behavior. In particular, handling of Ctrl-C. To make this possible, the generated files are now left behind after exit. The paths are based on hashing file contents, and it's stored in the system temporary directory, so this shouldn't result in too much garbage. See [#3821](https://github.com/commercialhaskell/stack/issues/3821). ## v1.6.5 Bug fixes: * Some unnecessary rebuilds when no files were changed are now avoided, by having a separate build cache for each component of a package. See [#3732](https://github.com/commercialhaskell/stack/issues/3732). * Correct the behavior of promoting a package from snapshot to local package. This would get triggered when version bounds conflicted in a snapshot, which could be triggered via Hackage revisions for old packages. This also should allow custom snapshots to define conflicting versions of packages without issue. See [Stackage issue #3185](https://github.com/fpco/stackage/issues/3185). * When promoting packages from snapshot to local, we were occassionally discarding the actual package location content and instead defaulting to pulling the package from the index. We now correctly retain this information. Note that if you were affected by this bug, you will likely need to delete the binary build cache associated with the relevant custom snapshot. See [#3714](https://github.com/commercialhaskell/stack/issues/3714). * `--no-rerun-tests` has been fixed. Previously, after running a test we were forgetting to record the result, which meant that all tests always ran even if they had already passed before. See [#3770](https://github.com/commercialhaskell/stack/pull/3770). * Includes a patched version of `hackage-security` which fixes both some issues around asynchronous exception handling, and moves from directory locking to file locking, making the update mechanism resilient against SIGKILL and machine failure. See [hackage-security #187](https://github.com/haskell/hackage-security/issues/187) and [#3073](https://github.com/commercialhaskell/stack/issues/3073). ## v1.6.3.1 Hackage-only release with no user facing changes (updated to build with newer version of hpack dependency). ## v1.6.3 Enhancements: * In addition to supporting `.tar.gz` and `.zip` files as remote archives, plain `.tar` files are now accepted too. This will additionally help with cases where HTTP servers mistakenly set the transfer encoding to `gzip`. See [#3647](https://github.com/commercialhaskell/stack/issues/3647). * Links to docs.haskellstack.org ignore Stack version patchlevel. * Downloading Docker-compatible `stack` binary ignores Stack version patchlevel. Bug fixes: * For versions of Cabal before 1.24, ensure that the dependencies of non-buildable components are part of the build plan to work around an old Cabal bug. See [#3631](https://github.com/commercialhaskell/stack/issues/3631). * Run the Cabal file checking in the `sdist` command more reliably by allowing the Cabal library to flatten the `GenericPackageDescription` itself. ## v1.6.1.1 Hackage-only release with no user facing changes (updated to build with newer dependency versions). ## v1.6.1 Major changes: * Complete overhaul of how snapshots are defined, the `packages` and `extra-deps` fields, and a number of related items. For full details, please see [the writeup on these changes](https://www.fpcomplete.com/blog/2017/07/stacks-new-extensible-snapshots). [PR #3249](https://github.com/commercialhaskell/stack/pull/3249), see the PR description for a number of related issues. * Upgraded to version 2.0 of the Cabal library. Behavior changes: * The `--install-ghc` flag is now on by default. For example, if you run `stack build` in a directory requiring a GHC that you do not currently have, Stack will automatically download and install that GHC. You can explicitly set `install-ghc: false` or pass the flag `--no-install-ghc` to regain the previous behavior. * `stack ghci` no longer loads modules grouped by package. This is always an improvement for plain ghci - it makes loading faster and less noisy. For intero, this has the side-effect that it will no longer load multiple packages that depend on TH loading relative paths. TH relative paths will still work when loading a single package into intero. See [#3309](https://github.com/commercialhaskell/stack/issues/3309) * Setting GHC options for a package via `ghc-options:` in your `stack.yaml` will promote it to a local package, providing for more consistency with flags and better reproducibility. See: [#849](https://github.com/commercialhaskell/stack/issues/849) * The `package-indices` setting with Hackage no longer works with the `00-index.tar.gz` tarball, but must use the `01-index.tar.gz` file to allow revised packages to be found. * Options passed via `--ghci-options` are now passed to the end of the invocation of ghci, instead of the middle. This allows using `+RTS` without an accompanying `-RTS`. * When auto-detecting `--ghc-build`, `tinfo6` is now preferred over `standard` if both versions of libtinfo are installed * Addition of `stack build --copy-compiler-tool`, to allow tools like intero to be installed globally for a particular compiler. [#2643](https://github.com/commercialhaskell/stack/issues/2643) * Stack will ask before saving hackage credentials to file. This new prompt can be avoided by using the `save-hackage-creds` setting. Please see [#2159](https://github.com/commercialhaskell/stack/issues/2159). * The `GHCRTS` environment variable will no longer be passed through to every program stack runs. Instead, it will only be passed through commands like `exec`, `runghc`, `script`, `ghci`, etc. See [#3444](https://github.com/commercialhaskell/stack/issues/3444). * `ghc-options:` for specific packages will now come after the options specified for all packages / particular sets of packages. See [#3573](https://github.com/commercialhaskell/stack/issues/3573). * The `pvp-bounds` feature is no longer fully functional, due to some issues with the Cabal library's printer. See [#3550](https://github.com/commercialhaskell/stack/issues/3550). Other enhancements: * The `with-hpack` configuration option specifies an Hpack executable to use instead of the Hpack bundled with Stack. Please see [#3179](https://github.com/commercialhaskell/stack/issues/3179). * It's now possible to skip tests and benchmarks using `--skip` flag * `GitSHA1` is now `StaticSHA256` and is implemented using the `StaticSize 64 ByteString` for improved performance. See [#3006](https://github.com/commercialhaskell/stack/issues/3006) * Dependencies via HTTP(S) archives have been generalized to allow local file path archives, as well as to support setting a cryptographic hash (SHA256) of the contents for better reproducibility. * Allow specifying `--git-branch` when upgrading * When running `stack upgrade` from a file which is different from the default executable path (e.g., on POSIX systems, `~/.local/bin/stack`), it will now additionally copy the new executable over the currently running `stack` executable. If permission is denied (such as in `/usr/local/bin/stack`), the user will be prompted to try again using `sudo`. This is intended to assist with the user experience when the `PATH` environment variable has not been properly configured, see [#3232](https://github.com/commercialhaskell/stack/issues/3232). * `stack setup` for ghcjs will now install `alex` and `happy` if they are not present. See [#3109](https://github.com/commercialhaskell/stack/issues/3232). * Added `stack ghci --only-main` flag, to skip loading / importing all but main modules. See the ghci documentation page for further info. * Allow GHC's colored output to show through. GHC colors output starting with version 8.2.1, for older GHC this does nothing. Sometimes GHC's heuristics would work fine even before this change, for example in `stack ghci`, but this override's GHC's heuristics when they're broken by our collecting and processing GHC's output. * Extended the `ghc-options` field to support `$locals`, `$targets`, and `$everything`. See: [#3329](https://github.com/commercialhaskell/stack/issues/3329) * Better error message for case that `stack ghci` file targets are combined with invalid package targets. See: [#3342](https://github.com/commercialhaskell/stack/issues/3342) * For profiling now uses `-fprof-auto -fprof-cafs` instead of the deprecated `-auto-all -caf-all`. See: [#3360](https://github.com/commercialhaskell/stack/issues/3360) * Better descriptions are now available for `stack upgrade --help`. See: [#3070](https://github.com/commercialhaskell/stack/issues/3070) * When using Nix, nix-shell now depends always on gcc to prevent build errors when using the FFI. As ghc depends on gcc anyway, this doesn't increase the dependency footprint. * `--cwd DIR` can now be passed to `stack exec` in order to execute the program in a different directory. See: [#3264](https://github.com/commercialhaskell/stack/issues/3264) * Plan construction will detect if you add an executable-only package as a library dependency, resulting in much clearer error messages. See: [#2195](https://github.com/commercialhaskell/stack/issues/2195). * Addition of `--ghc-options` to `stack script` to pass options directly to GHC. See: [#3454](https://github.com/commercialhaskell/stack/issues/3454) * Add hpack `package.yaml` to build Stack itself * Add `ignore-revision-mismatch` setting. See: [#3520](https://github.com/commercialhaskell/stack/issues/3520). * Log when each individual test suite finishes. See: [#3552](https://github.com/commercialhaskell/stack/issues/3552). * Avoid spurious rebuilds when using `--file-watch` by not watching files for executable, test and benchmark components that aren't a target. See: [#3483](https://github.com/commercialhaskell/stack/issues/3483). * Stack will now try to detect the width of the running terminal (only on POSIX for the moment) and use that to better display output messages. Work is ongoing, so some messages will not be optimal yet. The terminal width can be overridden with the new `--terminal-width` command-line option (this works even on non-POSIX). * Passing non local packages as targets to `stack ghci` will now cause them to be used as `-package` args along with package hiding. * Detect when user changed .cabal file instead of package.yaml. This was implemented upstream in hpack. See [#3383](https://github.com/commercialhaskell/stack/issues/3383). * Automatically run `autoreconf -i` as necessary when a `configure` script is missing. See [#3534](https://github.com/commercialhaskell/stack/issues/3534) * GHC bindists can now be identified by their SHA256 checksum in addition to their SHA1 checksum, allowing for more security in download. * For filesystem setup-info paths, it's no longer assumed that the directory is writable, instead a temp dir is used. See [#3188](https://github.com/commercialhaskell/stack/issues/3188). Bug fixes: * `stack hoogle` correctly generates Hoogle databases. See: [#3362](https://github.com/commercialhaskell/stack/issues/3362) * `stack --docker-help` is now clearer about --docker implying system-ghc: true, rather than both --docker and --no-docker. * `stack haddock` now includes package names for all modules in the Haddock index page. See: [#2886](https://github.com/commercialhaskell/stack/issues/2886) * Fixed an issue where Stack wouldn't detect missing Docker images properly with newer Docker versions. [#3171](https://github.com/commercialhaskell/stack/pull/3171) * Previously, cabal files with just test-suite could cause build to fail ([#2862](https://github.com/commercialhaskell/stack/issues/2862)) * If an invalid snapshot file has been detected (usually due to mismatched hashes), Stack will delete the downloaded file and recommend either retrying or filing an issue upstream. See [#3319](https://github.com/commercialhaskell/stack/issues/3319). * Modified the flag parser within Stack to match the behavior of Cabal's flag parser, which allows multiple sequential dashes. See [#3345](https://github.com/commercialhaskell/stack/issues/3345) * Now clears the hackage index cache if it is older than the downloaded index. Fixes potential issue if stack was interrupted when updating index. See [#3033](https://github.com/commercialhaskell/stack/issues/3033) * The Stack install script now respects the `-d` option. See [#3366](https://github.com/commercialhaskell/stack/pull/3366). * `stack script` can now handle relative paths to source files. See [#3372](https://github.com/commercialhaskell/stack/issues/3372). * Fixes explanation of why a target is needed by the build plan, when the target is an extra dependency from the commandline. See [#3378](https://github.com/commercialhaskell/stack/issues/3378). * Previously, if you delete a yaml file from ~/.stack/build-plan, it would trust the etag and not re-download. Fixed in this version. * Invoking `stack --docker` in parallel now correctly locks the sqlite database. See [#3400](https://github.com/commercialhaskell/stack/issues/3400). * docs.haskellstack.org RTD documentation search is replaced by the mkdocs search. Please see [#3376](https://github.com/commercialhaskell/stack/issues/3376). * `stack clean` now works with nix. See [#3468](https://github.com/commercialhaskell/stack/issues/3376). * `stack build --only-dependencies` no longer builds local project packages that are depended on. See [#3476](https://github.com/commercialhaskell/stack/issues/3476). * Properly handle relative paths stored in the precompiled cache files. See [#3431](https://github.com/commercialhaskell/stack/issues/3431). * In some cases, Cabal does not realize that it needs to reconfigure, and must be told to do so automatically. This would manifest as a "shadowed dependency" error message. We now force a reconfigure whenever a dependency is built, even if the package ID remained the same. See [#2781](https://github.com/commercialhaskell/stack/issues/2781). * When `--pvp-bounds` is enabled for sdist or upload, internal dependencies could cause errors when uploaded to hackage. This is fixed, see [#3290](https://github.com/commercialhaskell/stack/issues/3290) * Fixes a bug where nonexistent hackage versions would cause stack to suggest the same package name, without giving version info. See [#3562](https://github.com/commercialhaskell/stack/issues/3562) * Fixes a bug that has existed since 1.5.0, where `stack setup --upgrade-cabal` would say that Cabal is already the latest version, when it wasn't. * Ensure that an `extra-dep` from a local directory is not treated as a `$locals` for GHC options purposes. See [#3574](https://github.com/commercialhaskell/stack/issues/3574). * Building all executables only happens once instead of every time. See [#3229](https://github.com/commercialhaskell/stack/issues/3229) for more info. ## 1.5.1 Bug fixes: * Stack eagerly tries to parse all cabal files related to a snapshot. Starting with Stackage Nightly 2017-07-31, snapshots are using GHC 8.2.1, and the `ghc.cabal` file implicitly referenced uses the (not yet supported) Cabal 2.0 file format. Future releases of Stack will both be less eager about cabal file parsing and support Cabal 2.0. This patch simply bypasses the error for invalid parsing. ## 1.5.0 Behavior changes: * `stack profile` and `stack trace` now add their extra RTS arguments for benchmarks and tests to the beginning of the args, instead of the end. See [#2399](https://github.com/commercialhaskell/stack/issues/2399) * Support for Git-based indices has been removed. Other enhancements: * `stack setup` allow to control options passed to ghcjs-boot with `--ghcjs-boot-options` (one word at a time) and `--[no-]ghcjs-boot-clean` * `stack setup` now accepts a `--install-cabal VERSION` option which will install a specific version of the Cabal library globally. * Updates to store-0.4.1, which has improved performance and better error reporting for version tags. A side-effect of this is that all of stack's binary caches will be invalidated. * `stack solver` will now warn about unexpected cabal-install versions. See [#3044](https://github.com/commercialhaskell/stack/issues/3044) * Upstream packages unpacked to a temp dir are now deleted as soon as possible to avoid running out of space in `/tmp`. See [#3018](https://github.com/commercialhaskell/stack/issues/3018) * Add short synonyms for `test-arguments` and `benchmark-arguments` options. * Adds `STACK_WORK` environment variable, to specify work dir. See [#3063](https://github.com/commercialhaskell/stack/issues/3063) * Can now use relative paths for `extra-include-dirs` and `extra-lib-dirs`. See [#2830](https://github.com/commercialhaskell/stack/issues/2830) * Improved bash completion for many options, including `--ghc-options`, `--flag`, targets, and project executables for `exec`. * `--haddock-arguments` is actually used now when `haddock` is invoked during documentation generation. * `--[no-]haddock-hyperlink-source` flag added which allows toggling of sources being included in Haddock output. See [#3099](https://github.com/commercialhaskell/stack/issues/3099) * `stack ghci` will now skip building all local targets, even if they have downstream deps, as long as it's registered in the DB. * The pvp-bounds feature now supports adding `-revision` to the end of each value, e.g. `pvp-bounds: both-revision`. This means that, when uploading to Hackage, Stack will first upload your tarball with an unmodified `.cabal` file, and then upload a cabal file revision with the PVP bounds added. This can be useful—especially combined with the [Stackage no-revisions feature](http://www.snoyman.com/blog/2017/04/stackages-no-revisions-field)—as a method to ensure PVP compliance without having to proactively fix bounds issues for Stackage maintenance. * Expose a `save-hackage-creds` configuration option * On GHC <= 7.8, filters out spurious linker warnings on windows See [#3127](https://github.com/commercialhaskell/stack/pull/3127) * Better error messages when creating or building packages which alias wired-in packages. See [#3172](https://github.com/commercialhaskell/stack/issues/3172). * MinGW bin folder now is searched for dynamic libraries. See [#3126](https://github.com/commercialhaskell/stack/issues/3126) * When using Nix, nix-shell now depends always on git to prevent runtime errors while fetching metadata * The `stack unpack` command now accepts a form where an explicit Hackage revision hash is specified, e.g. `stack unpack foo-1.2.3@gitsha1:deadbeef`. Note that this should be considered _experimental_, Stack will likely move towards a different hash format in the future. * Binary "stack upgrade" will now warn if the installed executable is not on the PATH or shadowed by another entry. * Allow running tests on tarball created by sdist and upload [#717](https://github.com/commercialhaskell/stack/issues/717). Bug fixes: * Fixes case where `stack build --profile` might not cause executables / tests / benchmarks to be rebuilt. See [#2984](https://github.com/commercialhaskell/stack/issues/2984) * `stack ghci file.hs` now loads the file even if it isn't part of your project. * `stack clean --full` now works when docker is enabled. See [#2010](https://github.com/commercialhaskell/stack/issues/2010) * Fixes an issue where cyclic deps can cause benchmarks or tests to be run before they are built. See [#2153](https://github.com/commercialhaskell/stack/issues/2153) * Fixes `stack build --file-watch` in cases where a directory is removed See [#1838](https://github.com/commercialhaskell/stack/issues/1838) * Fixes `stack dot` and `stack list-dependencies` to use info from the package database for wired-in-packages (ghc, base, etc). See [#3084](https://github.com/commercialhaskell/stack/issues/3084) * Fixes `stack --docker build` when user is part of libvirt/libvirtd groups on Ubuntu Yakkety (16.10). See [#3092](https://github.com/commercialhaskell/stack/issues/3092) * Switching a package between extra-dep and local package now forces rebuild (previously it wouldn't if versions were the same). See [#2147](https://github.com/commercialhaskell/stack/issues/2147) * `stack upload` no longer reveals your password when you type it on MinTTY-based Windows shells, such as Cygwin and MSYS2. See [#3142](https://github.com/commercialhaskell/stack/issues/3142) * `stack script`'s import parser will now properly parse files that have Windows-style line endings (CRLF) ## 1.4.0 Release notes: * Docker images: [fpco/stack-full](https://hub.docker.com/r/fpco/stack-full/) and [fpco/stack-run](https://hub.docker.com/r/fpco/stack-run/) are no longer being built for LTS 8.0 and above. [fpco/stack-build](https://hub.docker.com/r/fpco/stack-build/) images continue to be built with a [simplified process](https://github.com/commercialhaskell/stack/tree/master/etc/dockerfiles/stack-build). [#624](https://github.com/commercialhaskell/stack/issues/624) Major changes: * A new command, `script`, has been added, intended to make the script interpreter workflow more reliable, easier to use, and more efficient. This command forces the user to provide a `--resolver` value, ignores all config files for more reproducible results, and optimizes the existing package check to make the common case of all packages already being present much faster. This mode does require that all packages be present in a snapshot, however. [#2805](https://github.com/commercialhaskell/stack/issues/2805) Behavior changes: * The default package metadata backend has been changed from Git to the 01-index.tar.gz file, from the hackage-security project. This is intended to address some download speed issues from Github for people in certain geographic regions. There is now full support for checking out specific cabal file revisions from downloaded tarballs as well. If you manually specify a package index with only a Git URL, Git will still be used. See [#2780](https://github.com/commercialhaskell/stack/issues/2780) * When you provide the `--resolver` argument to the `stack unpack` command, any packages passed in by name only will be looked up in the given snapshot instead of taking the latest version. For example, `stack --resolver lts-7.14 unpack mtl` will get version 2.2.1 of `mtl`, regardless of the latest version available in the package indices. This will also force the same cabal file revision to be used as is specified in the snapshot. Unpacking via a package identifier (e.g. `stack --resolver lts-7.14 unpack mtl-2.2.1`) will ignore any settings in the snapshot and take the most recent revision. For backwards compatibility with tools relying on the presence of a `00-index.tar`, Stack will copy the `01-index.tar` file to `00-index.tar`. Note, however, that these files are different; most importantly, 00-index contains only the newest revisions of cabal files, while 01-index contains all versions. You may still need to update your tooling. * Passing `--(no-)nix-*` options now no longer implies `--nix`, except for `--nix-pure`, so that the user preference whether or not to use Nix is honored even in the presence of options that change the Nix behavior. Other enhancements: * Internal cleanup: configuration types are now based much more on lenses * `stack build` and related commands now allow the user to disable debug symbol stripping with new `--no-strip`, `--no-library-stripping`, and `--no-executable-shipping` flags, closing [#877](https://github.com/commercialhaskell/stack/issues/877). Also turned error message for missing targets more readable ([#2384](https://github.com/commercialhaskell/stack/issues/2384)) * `stack haddock` now shows index.html paths when documentation is already up to date. Resolved [#781](https://github.com/commercialhaskell/stack/issues/781) * Respects the `custom-setup` field introduced in Cabal 1.24. This supercedes any `explicit-setup-deps` settings in your `stack.yaml` and trusts the package's `.cabal` file to explicitly state all its dependencies. * If system package installation fails, `get-stack.sh` will fail as well. Also shows warning suggesting to run `apt-get update` or similar, depending on the OS. ([#2898](https://github.com/commercialhaskell/stack/issues/2898)) * When `stack ghci` is run with a config with no packages (e.g. global project), it will now look for source files in the current work dir. ([#2878](https://github.com/commercialhaskell/stack/issues/2878)) * Bump to hpack 0.17.0 to allow `custom-setup` and `!include "..."` in `package.yaml`. * The script interpreter will now output error logging. In particular, this means it will output info about plan construction errors. ([#2879](https://github.com/commercialhaskell/stack/issues/2879)) * `stack ghci` now takes `--flag` and `--ghc-options` again (inadvertently removed in 1.3.0). ([#2986](https://github.com/commercialhaskell/stack/issues/2986)) * `stack exec` now takes `--rts-options` which passes the given arguments inside of `+RTS ... args .. -RTS` to the executable. This works around stack itself consuming the RTS flags on Windows. ([#2640](https://github.com/commercialhaskell/stack/issues/2640)) * Upgraded `http-client-tls` version, which now offers support for the `socks5://` and `socks5h://` values in the `http_proxy` and `https_proxy` environment variables. Bug fixes: * Bump to hpack 0.16.0 to avoid character encoding issues when reading and writing on non-UTF8 systems. * `stack ghci` will no longer ignore hsSourceDirs that contain `..`. ([#2895](https://github.com/commercialhaskell/stack/issues/2895)) * `stack list-dependencies --license` now works for wired-in-packages, like base. ([#2871](https://github.com/commercialhaskell/stack/issues/2871)) * `stack setup` now correctly indicates when it uses system ghc ([#2963](https://github.com/commercialhaskell/stack/issues/2963)) * Fix to `stack config set`, in 1.3.2 it always applied to the global project. ([#2709](https://github.com/commercialhaskell/stack/issues/2709)) * Previously, cabal files without exe or lib would fail on the "copy" step. ([#2862](https://github.com/commercialhaskell/stack/issues/2862)) * `stack upgrade --git` now works properly. Workaround for affected versions (>= 1.3.0) is to instead run `stack upgrade --git --source-only`. ([#2977](https://github.com/commercialhaskell/stack/issues/2977)) * Added support for GHC 8's slightly different warning format for dumping warnings from logs. * Work around a bug in Cabal/GHC in which package IDs are not unique for different source code, leading to Stack not always rebuilding packages depending on local packages which have changed. ([#2904](https://github.com/commercialhaskell/stack/issues/2904)) ## 1.3.2 Bug fixes: * `stack config set` can now be used without a compiler installed [#2852](https://github.com/commercialhaskell/stack/issues/2852). * `get-stack.sh` now installs correct binary on ARM for generic linux and raspbian, closing [#2856](https://github.com/commercialhaskell/stack/issues/2856). * Correct the testing of whether a package database exists by checking for the `package.cache` file itself instead of the containing directory. * Revert a change in the previous release which made it impossible to set local extra-dep packages as targets. This was overkill; we really only wanted to disable their test suites, which was already handled by a later patch. [#2849](https://github.com/commercialhaskell/stack/issues/2849) * `stack new` always treats templates as being UTF-8 encoding, ignoring locale settings on a local machine. See [Yesod mailing list discussion](https://groups.google.com/d/msg/yesodweb/ZyWLsJOtY0c/aejf9E7rCAAJ) ## 1.3.0 Release notes: * For the _next_ stack release after this one, we are planning changes to our Linux releases, including dropping our Ubuntu, Debian, CentOS, and Fedora package repositories and switching to statically linked binaries. See [#2534](https://github.com/commercialhaskell/stack/issues/2534). Note that upgrading without a package manager has gotten easier with new binary upgrade support in `stack upgrade` (see the Major Changes section below for more information). In addition, the get.haskellstack.org script no longer installs from Ubuntu, Debian, CentOS, or Fedora package repositories. Instead it places a generic binary in /usr/local/bin. Major changes: * Stack will now always use its own GHC installation, even when a suitable GHC installation is available on the PATH. To get the old behaviour, use the `--system-ghc` flag or run `stack config set system-ghc --global true`. Docker- and Nix-enabled projects continue to use the GHC installations in their environment by default. NB: Scripts that previously used stack in combination with a system GHC installation should now include a `stack setup` line or use the `--install-ghc` flag. [#2221](https://github.com/commercialhaskell/stack/issues/2221) * `stack ghci` now defaults to skipping the build of target packages, because support has been added for invoking "initial build steps", which create autogen files and run preprocessors. The `--no-build` flag is now deprecated because it should no longer be necessary. See [#1364](https://github.com/commercialhaskell/stack/issues/1364) * Stack is now capable of doing binary upgrades instead of always recompiling a new version from source. Running `stack upgrade` will now default to downloading a binary version of Stack from the most recent release, if one is available. See `stack upgrade --help` for more options. [#1238](https://github.com/commercialhaskell/stack/issues/1238) Behavior changes: * Passing `--resolver X` with a Stack command which forces creation of a global project config, will pass resolver X into the initial config. See [#2579](https://github.com/commercialhaskell/stack/issues/2229). * Switch the "Run from outside project" messages to debug-level, to avoid spamming users in the normal case of non-project usage * If a remote package is specified (such as a Git repo) without an explicit `extra-dep` setting, a warning is given to the user to provide one explicitly. Other enhancements: * `stack haddock` now supports `--haddock-internal`. See [#2229](https://github.com/commercialhaskell/stack/issues/2229) * Add support for `system-ghc` and `install-ghc` fields to `stack config set` command. * Add `ghc-build` option to override autodetected GHC build to use (e.g. gmp4, tinfo6, nopie) on Linux. * `stack setup` detects systems where gcc enables PIE by default (such as Ubuntu 16.10 and Hardened Gentoo) and adjusts the GHC `configure` options accordingly. [#2542](https://github.com/commercialhaskell/stack/issues/2542) * Upload to Hackage with HTTP digest instead of HTTP basic. * Make `stack list-dependencies` understand all of the `stack dot` options too. * Add the ability for `stack list-dependencies` to list dependency licenses by passing the `--license` flag. * Dump logs that contain warnings for any local non-dependency packages [#2545](https://github.com/commercialhaskell/stack/issues/2545) * Add the `dump-logs` config option and `--dump-logs` command line option to get full build output on the console. [#426](https://github.com/commercialhaskell/stack/issues/426) * Add the `--open` option to "stack hpc report" command, causing the report to be opened in the browser. * The `stack config set` command now accepts a `--global` flag for suitable fields which causes it to modify the global user configuration (`~/.stack/config.yaml`) instead of the project configuration. [#2675](https://github.com/commercialhaskell/stack/pull/2675) * Information on the latest available snapshots is now downloaded from S3 instead of stackage.org, increasing reliability in case of stackage.org outages. [#2653](https://github.com/commercialhaskell/stack/pull/2653) * `stack dot` and `stack list-dependencies` now take targets and flags. [#1919](https://github.com/commercialhaskell/stack/issues/1919) * Deprecate `stack setup --stack-setup-yaml` for `--setup-info-yaml` based on discussion in [#2647](https://github.com/commercialhaskell/stack/issues/2647). * The `--main-is` flag for GHCI now implies the TARGET, fixing [#1845](https://github.com/commercialhaskell/stack/issues/1845). * `stack ghci` no longer takes all build options, as many weren't useful [#2199](https://github.com/commercialhaskell/stack/issues/2199) * `--no-time-in-log` option, to make verbose logs more diffable [#2727](https://github.com/commercialhaskell/stack/issues/2727) * `--color` option added to override auto-detection of ANSI support [#2725](https://github.com/commercialhaskell/stack/issues/2725) * Missing extra-deps are now warned about, adding a degree of typo detection [#1521](https://github.com/commercialhaskell/stack/issues/1521) * No longer warns about missing build-tools if they are on the PATH. [#2235](https://github.com/commercialhaskell/stack/issues/2235) * Replace enclosed-exceptions with safe-exceptions. [#2768](https://github.com/commercialhaskell/stack/issues/2768) * The install location for GHC and other programs can now be configured with the `local-programs-path` option in `config.yaml`. [#1644](https://github.com/commercialhaskell/stack/issues/1644) * Added option to add nix dependencies as nix GC roots * Proper pid 1 (init) process for `stack exec` with Docker * Dump build logs if they contain warnings. [#2545](https://github.com/commercialhaskell/stack/issues/2545) * Docker: redirect stdout of `docker pull` to stderr so that it will not interfere with output of other commands. * Nix & docker can be activated at the same time, in order to run stack in a nix-shell in a container, preferably from an image already containing the nix dependencies in its /nix/store * Stack/nix: Dependencies can be added as nix GC roots, so they are not removed when running `nix-collect-garbage` Bug fixes: * Fixed a gnarly bug where programs and package tarballs sometimes have corrupted downloads. See [#2657](https://github.com/commercialhaskell/stack/issues/2568). * Add proper support for non-ASCII characters in file paths for the `sdist` command. See [#2549](https://github.com/commercialhaskell/stack/issues/2549) * Never treat `extra-dep` local packages as targets. This ensures things like test suites are not run for these packages, and that build output is not hidden due to their presence. * Fix a resource leak in `sinkProcessStderrStdout` which could affect much of the codebase, in particular copying precompiled packages. [#1979](https://github.com/commercialhaskell/stack/issues/1979) * Docker: ensure that interrupted extraction process does not cause corrupt file when downloading a Docker-compatible Stack executable [#2568](https://github.com/commercialhaskell/stack/issues/2568) * Fixed running `stack hpc report` on package targets. [#2664](https://github.com/commercialhaskell/stack/issues/2664) * Fix a long-standing performance regression where stack would parse the .dump-hi files of the library components of local packages twice. [#2658](https://github.com/commercialhaskell/stack/pull/2658) * Fixed a regression in "stack ghci --no-load", where it would prompt for a main module to load. [#2603](https://github.com/commercialhaskell/stack/pull/2603) * Build Setup.hs files with the threaded RTS, mirroring the behavior of cabal-install and enabling more complex build systems in those files. * Fixed a bug in passing along `--ghc-options` to ghcjs. They were being provided as `--ghc-options` to Cabal, when it needs to be `--ghcjs-options`. [#2714](https://github.com/commercialhaskell/stack/issues/2714) * Launch Docker from the project root regardless of the working directory Stack is invoked from. This means paths relative to the project root (e.g. environment files) can be specified in `stack.yaml`'s docker `run-args`. * `stack setup --reinstall` now behaves as expected. [#2554](https://github.com/commercialhaskell/stack/issues/2554) ## 1.2.0 Release notes: * On many Un*x systems, Stack can now be installed with a simple one-liner: wget -qO- https://get.haskellstack.org/ | sh * The fix for [#2175](https://github.com/commercialhaskell/stack/issues/2175) entails that stack must perform a full clone of a large Git repo of Hackage meta-information. The total download size is about 200 MB. Please be aware of this when upgrading your stack installation. * If you use Mac OS X, you may want to delay upgrading to macOS Sierra as there are reports of GHC panics when building some packages (including Stack itself). See [#2577](https://github.com/commercialhaskell/stack/issues/2577) * This version of Stack does not build on ARM or PowerPC systems (see [store#37](https://github.com/fpco/store/issues/37)). Please stay with version 1.1.2 for now on those architectures. This will be rectified soon! * We are now releasing a [statically linked Stack binary for 64-bit Linux](https://get.haskellstack.org/stable/linux-x86_64-static.tar.gz). Please try it and let us know if you run into any trouble on your platform. * We are planning some changes to our Linux releases, including dropping our Ubuntu, Debian, CentOS, and Fedora package repositories and switching to statically linked binaries. We would value your feedback in [#2534](https://github.com/commercialhaskell/stack/issues/2534). Major changes: * Add `stack hoogle` command. [#55](https://github.com/commercialhaskell/stack/issues/55) * Support for absolute file path in `url` field of `setup-info` or `--ghc-bindist` * Add support for rendering GHCi scripts targeting different GHCi like applications [#2457](https://github.com/commercialhaskell/stack/pull/2457) Behavior changes: * Remove `stack ide start` and `stack ide load-targets` commands. [#2178](https://github.com/commercialhaskell/stack/issues/2178) * Support .buildinfo files in `stack ghci`. [#2242](https://github.com/commercialhaskell/stack/pull/2242) * Support -ferror-spans syntax in GHC error messages. * Avoid unpacking ghc to `/tmp` [#996](https://github.com/commercialhaskell/stack/issues/996) * The Linux `gmp4` GHC bindist is no longer considered a full-fledged GHC variant and can no longer be specified using the `ghc-variant` option, and instead is treated more like a slightly different platform. Other enhancements: * Use the `store` package for binary serialization of most caches. * Only require minor version match for Docker stack exe. This way, we can make patch releases for version bounds and similar build issues without needing to upload new binaries for Docker. * Stack/Nix: Passes the right ghc derivation as an argument to the `shell.nix` when a custom `shell.nix` is used See [#2243](https://github.com/commercialhaskell/stack/issues/2243) * Stack/Nix: Sets `LD_LIBRARY_PATH` so packages using C libs for Template Haskell can work (See _e.g._ [this HaskellR issue](https://github.com/tweag/HaskellR/issues/253)) * Parse CLI arguments and configuration files into less permissive types, improving error messages for bad inputs. [#2267](https://github.com/commercialhaskell/stack/issues/2267) * Add the ability to explicitly specify a gcc executable. [#593](https://github.com/commercialhaskell/stack/issues/593) * Nix: No longer uses LTS mirroring in nixpkgs. Gives to nix-shell a derivation like `haskell.compiler.ghc801` See [#2259](https://github.com/commercialhaskell/stack/issues/2259) * Perform some subprocesses during setup concurrently, slightly speeding up most commands. [#2346](https://github.com/commercialhaskell/stack/pull/2346) * `stack setup` no longer unpacks to the system temp dir on posix systems. [#996](https://github.com/commercialhaskell/stack/issues/996) * `stack setup` detects libtinfo6 and ncurses6 and can download alternate GHC bindists [#257](https://github.com/commercialhaskell/stack/issues/257) [#2302](https://github.com/commercialhaskell/stack/issues/2302). * `stack setup` detects Linux ARMv7 downloads appropriate GHC bindist [#2103](https://github.com/commercialhaskell/stack/issues/2103) * Custom `stack` binaries list dependency versions in output for `--version`. See [#2222](https://github.com/commercialhaskell/stack/issues/2222) and [#2450](https://github.com/commercialhaskell/stack/issues/2450). * Use a pretty printer to output dependency resolution errors. [#1912](https://github.com/commercialhaskell/stack/issues/1912) * Remove the `--os` flag [#2227](https://github.com/commercialhaskell/stack/issues/2227) * Add 'netbase' and 'ca-certificates' as dependency for .deb packages. [#2293](https://github.com/commercialhaskell/stack/issues/2293). * Add `stack ide targets` command. * Enhance debug logging with subprocess timings. * Pretty-print YAML parse errors [#2374](https://github.com/commercialhaskell/stack/issues/2374) * Clarify confusing `stack setup` output [#2314](https://github.com/commercialhaskell/stack/issues/2314) * Delete `Stack.Types` multimodule to improve build times [#2405](https://github.com/commercialhaskell/stack/issues/2405) * Remove spurious newlines in build logs [#2418](https://github.com/commercialhaskell/stack/issues/2418) * Interpreter: Provide a way to hide implicit packages [#1208](https://github.com/commercialhaskell/stack/issues/1208) * Check executability in exec lookup [#2489](https://github.com/commercialhaskell/stack/issues/2489) Bug fixes: * Fix cabal warning about use of a deprecated cabal flag [#2350](https://github.com/commercialhaskell/stack/issues/2350) * Support most executable extensions on Windows [#2225](https://github.com/commercialhaskell/stack/issues/2225) * Detect resolver change in `stack solver` [#2252](https://github.com/commercialhaskell/stack/issues/2252) * Fix a bug in docker image creation where the wrong base image was selected [#2376](https://github.com/commercialhaskell/stack/issues/2376) * Ignore special entries when unpacking tarballs [#2361](https://github.com/commercialhaskell/stack/issues/2361) * Fixes src directory pollution of `style.css` and `highlight.js` with GHC 8's haddock [#2429](https://github.com/commercialhaskell/stack/issues/2429) * Handle filepaths with spaces in `stack ghci` [#2266](https://github.com/commercialhaskell/stack/issues/2266) * Apply ghc-options to snapshot packages [#2289](https://github.com/commercialhaskell/stack/issues/2289) * stack sdist: Fix timestamp in tarball [#2394](https://github.com/commercialhaskell/stack/pull/2394) * Allow global Stack arguments with a script [#2316](https://github.com/commercialhaskell/stack/issues/2316) * Inconsistency between ToJSON and FromJSON instances of PackageLocation [#2412](https://github.com/commercialhaskell/stack/pull/2412) * Perform Unicode normalization on filepaths [#1810](https://github.com/commercialhaskell/stack/issues/1810) * Solver: always keep ghc wired-in as hard constraints [#2453](https://github.com/commercialhaskell/stack/issues/2453) * Support OpenBSD's tar where possible, require GNU tar for xz support [#2283](https://github.com/commercialhaskell/stack/issues/2283) * Fix using --coverage with Cabal-1.24 [#2424](https://github.com/commercialhaskell/stack/issues/2424) * When marking exe installed, remove old version [#2373](https://github.com/commercialhaskell/stack/issues/2373) * Stop truncating all-cabal-hashes git repo [#2175](https://github.com/commercialhaskell/stack/issues/2175) * Handle non-ASCII filenames on Windows [#2491](https://github.com/commercialhaskell/stack/issues/2491) * Avoid using multiple versions of a package in script interpreter by passing package-id to ghc/runghc [#1957](https://github.com/commercialhaskell/stack/issues/1957) * Only pre-load compiler version when using nix integration [#2459](https://github.com/commercialhaskell/stack/issues/2459) * Solver: parse cabal errors also on Windows [#2502](https://github.com/commercialhaskell/stack/issues/2502) * Allow exec and ghci commands in interpreter mode. Scripts can now automatically open in the repl by using `exec ghci` instead of `runghc` in the shebang command. [#2510](https://github.com/commercialhaskell/stack/issues/2510) * Now consider a package to be dirty when an extra-source-file is changed. See [#2040](https://github.com/commercialhaskell/stack/issues/2040) ## 1.1.2 Release notes: * Official FreeBSD binaries are [now available](http://docs.haskellstack.org/en/stable/install_and_upgrade/#freebsd) [#1253](https://github.com/commercialhaskell/stack/issues/1253). Major changes: * Extensible custom snapshots implemented. These allow you to define snapshots which extend other snapshots. See [#863](https://github.com/commercialhaskell/stack/issues/863). Local file custom snapshots can now be safely updated without changing their name. Remote custom snapshots should still be treated as immutable. Behavior changes: * `stack path --compiler` was added in the last release, to yield a path to the compiler. Unfortunately, `--compiler` is a global option that is useful to use with `stack path`. The same functionality is now provided by `stack path --compiler-exe`. See [#2123](https://github.com/commercialhaskell/stack/issues/2123) * For packages specified in terms of a git or hg repo, the hash used in the location has changed. This means that existing downloads from older stack versions won't be used. This is a side-effect of the fix to [#2133](https://github.com/commercialhaskell/stack/issues/2133) * `stack upgrade` no longer pays attention to local stack.yaml files, just the global config and CLI options. [#1392](https://github.com/commercialhaskell/stack/issues/1392) * `stack ghci` now uses `:add` instead of `:load`, making it potentially work better with user scripts. See [#1888](https://github.com/commercialhaskell/stack/issues/1888) Other enhancements: * Grab Cabal files via Git SHA to avoid regressions from Hackage revisions [#2070](https://github.com/commercialhaskell/stack/pull/2070) * Custom snapshots now support `ghc-options`. * Package git repos are now re-used rather than re-cloned. See [#1620](https://github.com/commercialhaskell/stack/issues/1620) * `DESTDIR` is filtered from environment when installing GHC. See [#1460](https://github.com/commercialhaskell/stack/issues/1460) * `stack haddock` now supports `--hadock-arguments`. See [#2144](https://github.com/commercialhaskell/stack/issues/2144) * Signing: warn if GPG_TTY is not set as per `man gpg-agent` Bug fixes: * Now ignore project config when doing `stack init` or `stack new`. See [#2110](https://github.com/commercialhaskell/stack/issues/2110) * Packages specified by git repo can now have submodules. See [#2133](https://github.com/commercialhaskell/stack/issues/2133) * Fix of hackage index fetch retry. See re-opening of [#1418](https://github.com/commercialhaskell/stack/issues/1418#issuecomment-217633843) * HPack now picks up changes to filesystem other than package.yaml. See [#2051](https://github.com/commercialhaskell/stack/issues/2051) * "stack solver" no longer suggests --omit-packages. See [#2031](https://github.com/commercialhaskell/stack/issues/2031) * Fixed an issue with building Cabal's Setup.hs. See [#1356](https://github.com/commercialhaskell/stack/issues/1356) * Package dirtiness now pays attention to deleted files. See [#1841](https://github.com/commercialhaskell/stack/issues/1841) * `stack ghci` now uses `extra-lib-dirs` and `extra-include-dirs`. See [#1656](https://github.com/commercialhaskell/stack/issues/1656) * Relative paths outside of source dir added via `qAddDependentFile` are now checked for dirtiness. See [#1982](https://github.com/commercialhaskell/stack/issues/1982) * Signing: always use `--with-fingerprints` ## 1.1.0 Release notes: * Added Ubuntu 16.04 LTS (xenial) Apt repo. * No longer uploading new versions to Fedora 21 repo. Behavior changes: * Snapshot packages are no longer built with executable profiling. See [#1179](https://github.com/commercialhaskell/stack/issues/1179). * `stack init` now ignores symlinks when searching for cabal files. It also now ignores any directory that begins with `.` (as well as `dist` dirs) - before it would only ignore `.git`, `.stack-work`, and `dist`. * The stack executable is no longer built with `-rtsopts`. Before, when `-rtsopts` was enabled, stack would process `+RTS` options even when intended for some other program, such as when used with `stack exec -- prog +RTS`. See [#2022](https://github.com/commercialhaskell/stack/issues/2022). * The `stack path --ghc-paths` option is deprecated and renamed to `--programs`. `--compiler` is added, which points directly at the compiler used in the current project. `--compiler-bin` points to the compiler's bin dir. * For consistency with the `$STACK_ROOT` environment variable, the `stack path --global-stack-root` flag and the `global-stack-root` field in the output of `stack path` are being deprecated and replaced with the `stack-root` flag and output field. Additionally, the stack root can now be specified via the `--stack-root` command-line flag. See [#1148](https://github.com/commercialhaskell/stack/issues/1148). * `stack sig` GPG-related sub-commands were removed (folded into `upload` and `sdist`) * GPG signing of packages while uploading to Hackage is now the default. Use `upload --no-signature` if you would rather not contribute your package signature. If you don't yet have a GPG keyset, read this [blog post on GPG keys](https://fpcomplete.com/blog/2016/05/stack-security-gnupg-keys). We can add a stack.yaml config setting to disable signing if some people desire it. We hope that people will sign. Later we will be adding GPG signature verification options. * `stack build pkg-1.2.3` will now build even if the snapshot has a different package version - it is treated as an extra-dep. `stack build local-pkg-1.2.3` is an error even if the version number matches the local package [#2028](https://github.com/commercialhaskell/stack/issues/2028). * Having a `nix:` section no longer implies enabling nix build. This allows the user to globally configure whether nix is used (unless the project overrides the default explicitly). See [#1924](https://github.com/commercialhaskell/stack/issues/1924). * Remove deprecated valid-wanted field. * Docker: mount home directory in container [#1949](https://github.com/commercialhaskell/stack/issues/1949). * Deprecate `--local-bin-path` instead `--local-bin`. * `stack image`: allow absolute source paths for `add`. Other enhancements: * `stack haddock --open [PACKAGE]` opens the local haddocks in the browser. * Fix too much rebuilding when enabling/disabling profiling flags. * `stack build pkg-1.0` will now build `pkg-1.0` even if the snapshot specifies a different version (it introduces a temporary extra-dep) * Experimental support for `--split-objs` added [#1284](https://github.com/commercialhaskell/stack/issues/1284). * `git` packages with submodules are supported by passing the `--recursive` flag to `git clone`. * When using [hpack](https://github.com/sol/hpack), only regenerate cabal files when hpack files change. * hpack files can now be used in templates * `stack ghci` now runs ghci as a separate process [#1306](https://github.com/commercialhaskell/stack/issues/1306) * Retry when downloading snapshots and package indices * Many build options are configurable now in `stack.yaml`: ``` build: library-profiling: true executable-profiling: true haddock: true haddock-deps: true copy-bins: true prefetch: true force-dirty: true keep-going: true test: true test-arguments: rerun-tests: true additional-args: ['-fprof'] coverage: true no-run-tests: true bench: true benchmark-opts: benchmark-arguments: -O2 no-run-benchmarks: true reconfigure: true cabal-verbose: true ``` * A number of URLs are now configurable, useful for firewalls. See [#1794](https://github.com/commercialhaskell/stack/issues/1884). * Suggest causes when executables are missing. * Allow `--omit-packages` even without `--solver`. * Improve the generated stack.yaml. * Improve ghci results after :load Main module collision with main file path. * Only load the hackage index if necessary [#1883](https://github.com/commercialhaskell/stack/issues/1883), [#1892](https://github.com/commercialhaskell/stack/issues/1892). * init: allow local packages to be deps of deps [#1965](https://github.com/commercialhaskell/stack/issues/1965). * Always use full fingerprints from GPG [#1952](https://github.com/commercialhaskell/stack/issues/1952). * Default to using `gpg2` and fall back to `gpg` [#1976](https://github.com/commercialhaskell/stack/issues/1976). * Add a flag for --verbosity silent. * Add `haddock --open` flag [#1396](https://github.com/commercialhaskell/stack/issues/1396). Bug fixes: * Package tarballs would fail to unpack. [#1884](https://github.com/commercialhaskell/stack/issues/1884). * Fixed errant warnings about missing modules, after deleted and removed from cabal file [#921](https://github.com/commercialhaskell/stack/issues/921) [#1805](https://github.com/commercialhaskell/stack/issues/1805). * Now considers a package to dirty when the hpack file is changed [#1819](https://github.com/commercialhaskell/stack/issues/1819). * Nix: cancelling a stack build now exits properly rather than dropping into a nix-shell [#1778](https://github.com/commercialhaskell/stack/issues/1778). * `allow-newer: true` now causes `--exact-configuration` to be passed to Cabal. See [#1579](https://github.com/commercialhaskell/stack/issues/1579). * `stack solver` no longer fails with `InvalidRelFile` for relative package paths including `..`. See [#1954](https://github.com/commercialhaskell/stack/issues/1954). * Ignore emacs lock files when finding .cabal [#1897](https://github.com/commercialhaskell/stack/issues/1897). * Use lenient UTF-8 decode for build output [#1945](https://github.com/commercialhaskell/stack/issues/1945). * Clear index cache whenever index updated [#1962](https://github.com/commercialhaskell/stack/issues/1962). * Fix: Building a container image drops a .stack-work dir in the current working (sub)directory [#1975](https://github.com/commercialhaskell/stack/issues/1975). * Fix: Rebuilding when disabling profiling [#2023](https://github.com/commercialhaskell/stack/issues/2023). ## 1.0.4.3 Bug fixes: * Don't delete contents of ~/.ssh when using `stack clean --full` with Docker enabled [#2000](https://github.com/commercialhaskell/stack/issues/2000) ## 1.0.4.2 Build with path-io-1.0.0. There are no changes in behaviour from 1.0.4, so no binaries are released for this version. ## 1.0.4.1 Fixes build with aeson-0.11.0.0. There are no changes in behaviour from 1.0.4, so no binaries are released for this version. ## 1.0.4 Major changes: * Some notable changes in `stack init`: * Overall it should now be able to initialize almost all existing cabal packages out of the box as long as the package itself is consistently defined. * Choose the best possible snapshot and add extra dependencies on top of a snapshot resolver rather than a compiler resolver - [#1583](https://github.com/commercialhaskell/stack/pull/1583) * Automatically omit a package (`--omit-packages`) when it is compiler incompatible or when there are packages with conflicting dependency requirements - [#1674](https://github.com/commercialhaskell/stack/pull/1674). * Some more changes for a better user experience. Please refer to the doc guide for details. * Add support for hpack, alternative package description format [#1679](https://github.com/commercialhaskell/stack/issues/1679) Other enhancements: * Docker: pass ~/.ssh and SSH auth socket into container, so that git repos work [#1358](https://github.com/commercialhaskell/stack/issues/1358). * Docker: strip suffix from docker --version. [#1653](https://github.com/commercialhaskell/stack/issues/1653) * Docker: pass USER and PWD environment variables into container. * On each run, stack will test the stack root directory (~/.stack), and the project and package work directories (.stack-work) for whether they are owned by the current user and abort if they are not. This precaution can be disabled with the `--allow-different-user` flag or `allow-different-user` option in the global config (~/.stack/config.yaml). [#471](https://github.com/commercialhaskell/stack/issues/471) * Added `stack clean --full` option for full working dir cleanup. * YAML config: support Zip archives. * Redownload build plan if parsing fails [#1702](https://github.com/commercialhaskell/stack/issues/1702). * Give mustache templates access to a 'year' tag [#1716](https://github.com/commercialhaskell/stack/pull/1716). * Have "stack ghci" warn about module name aliasing. * Add "stack ghci --load-local-deps". * Build Setup.hs with -rtsopts [#1687](https://github.com/commercialhaskell/stack/issues/1687). * `stack init` accepts a list of directories. * Add flag infos to DependencyPlanFailures (for better error output in case of flags) [#713](https://github.com/commercialhaskell/stack/issues/713) * `stack new --bare` complains for overwrites, and add `--force` option [#1597](https://github.com/commercialhaskell/stack/issues/1597). Bug fixes: * Previously, `stack ghci` would fail with `cannot satisfy -package-id` when the implicit build step changes the package key of some dependency. * Fix: Building with ghcjs: "ghc-pkg: Prelude.chr: bad argument: 2980338" [#1665](https://github.com/commercialhaskell/stack/issues/1665). * Fix running test / bench with `--profile` / `--trace`. * Fix: build progress counter is no longer visible [#1685](https://github.com/commercialhaskell/stack/issues/1685). * Use "-RTS" w/ profiling to allow extra args [#1772](https://github.com/commercialhaskell/stack/issues/1772). * Fix withUnpackedTarball7z to find name of srcDir after unpacking (fixes `stack setup` fails for ghcjs project on windows) [#1774](https://github.com/commercialhaskell/stack/issues/1774). * Add space before auto-generated bench opts (makes profiling options work uniformly for applications and benchmark suites) [#1771](https://github.com/commercialhaskell/stack/issues/1771). * Don't try to find plugin if it resembles flag. * Setup.hs changes cause package dirtiness [#1711](https://github.com/commercialhaskell/stack/issues/1711). * Send "stack templates" output to stdout [#1792](https://github.com/commercialhaskell/stack/issues/1792). ## 1.0.2 Release notes: - Arch Linux: Stack has been adopted into the [official community repository](https://www.archlinux.org/packages/community/x86_64/stack/), so we will no longer be updating the AUR with new versions. See the [install/upgrade guide](http://docs.haskellstack.org/en/stable/install_and_upgrade/#arch-linux) for current download instructions. Major changes: - `stack init` and `solver` overhaul [#1583](https://github.com/commercialhaskell/stack/pull/1583) Other enhancements: - Disable locale/codepage hacks when GHC >=7.10.3 [#1552](https://github.com/commercialhaskell/stack/issues/1552) - Specify multiple images to build for `stack image container` [docs](http://docs.haskellstack.org/en/stable/yaml_configuration/#image) - Specify which executables to include in images for `stack image container` [docs](http://docs.haskellstack.org/en/stable/yaml_configuration/#image) - Docker: pass supplementary groups and umask into container - If git fetch fails wipe the directory and try again from scratch [#1418](https://github.com/commercialhaskell/stack/issues/1418) - Warn if newly installed executables won't be available on the PATH [#1362](https://github.com/commercialhaskell/stack/issues/1362) - stack.yaml: for `stack image container`, specify multiple images to generate, and which executables should be added to those images - GHCI: add interactive Main selection [#1068](https://github.com/commercialhaskell/stack/issues/1068) - Care less about the particular name of a GHCJS sdist folder [#1622](https://github.com/commercialhaskell/stack/issues/1622) - Unified Enable/disable help messaging [#1613](https://github.com/commercialhaskell/stack/issues/1613) Bug fixes: - Don't share precompiled packages between GHC/platform variants and Docker [#1551](https://github.com/commercialhaskell/stack/issues/1551) - Properly redownload corrupted downloads with the correct file size. [Mailing list discussion](https://groups.google.com/d/msg/haskell-stack/iVGDG5OHYxs/FjUrR5JsDQAJ) - Gracefully handle invalid paths in error/warning messages [#1561](https://github.com/commercialhaskell/stack/issues/1561) - Nix: select the correct GHC version corresponding to the snapshot even when an abstract resolver is passed via `--resolver` on the command-line. [#1641](https://github.com/commercialhaskell/stack/issues/1641) - Fix: Stack does not allow using an external package from ghci [#1557](https://github.com/commercialhaskell/stack/issues/1557) - Disable ambiguous global '--resolver' option for 'stack init' [#1531](https://github.com/commercialhaskell/stack/issues/1531) - Obey `--no-nix` flag - Fix: GHCJS Execute.hs: Non-exhaustive patterns in lambda [#1591](https://github.com/commercialhaskell/stack/issues/1591) - Send file-watch and sticky logger messages to stderr [#1302](https://github.com/commercialhaskell/stack/issues/1302) [#1635](https://github.com/commercialhaskell/stack/issues/1635) - Use globaldb path for querying Cabal version [#1647](https://github.com/commercialhaskell/stack/issues/1647) ## 1.0.0 Release notes: * We're calling this version 1.0.0 in preparation for Stackage LTS 4. Note, however, that this does not mean the code's API will be stable as this is primarily an end-user tool. Enhancements: * Added flag `--profile` flag: passed with `stack build`, it will enable profiling, and for `--bench` and `--test` it will generate a profiling report by passing `+RTS -p` to the executable(s). Great for using like `stack build --bench --profile` (remember that enabling profile will slow down your benchmarks by >4x). Run `stack build --bench` again to disable the profiling and get proper speeds * Added flag `--trace` flag: just like `--profile`, it enables profiling, but instead of generating a report for `--bench` and `--test`, prints out a stack trace on exception. Great for using like `stack build --test --trace` * Nix: all options can be overridden on command line [#1483](https://github.com/commercialhaskell/stack/issues/1483) * Nix: build environments (shells) are now pure by default. * Make verbosity silent by default in script interpreter mode [#1472](https://github.com/commercialhaskell/stack/issues/1472) * Show a message when resetting git commit fails [#1453](https://github.com/commercialhaskell/stack/issues/1453) * Improve Unicode handling in project/package names [#1337](https://github.com/commercialhaskell/stack/issues/1337) * Fix ambiguity between a stack command and a filename to execute (prefer `stack` subcommands) [#1471](https://github.com/commercialhaskell/stack/issues/1471) * Support multi line interpreter directive comments [#1394](https://github.com/commercialhaskell/stack/issues/1394) * Handle space separated pids in ghc-pkg dump (for GHC HEAD) [#1509](https://github.com/commercialhaskell/stack/issues/1509) * Add ghci --no-package-hiding option [#1517](https://github.com/commercialhaskell/stack/issues/1517) * `stack new` can download templates from URL [#1466](https://github.com/commercialhaskell/stack/issues/1466) Bug fixes: * Nix: stack exec options are passed properly to the stack sub process [#1538](https://github.com/commercialhaskell/stack/issues/1538) * Nix: specifying a shell-file works in any current working directory [#1547](https://github.com/commercialhaskell/stack/issues/1547) * Nix: use `--resolver` argument * Docker: fix missing image message and '--docker-auto-pull' * No HTML escaping for "stack new" template params [#1475](https://github.com/commercialhaskell/stack/issues/1475) * Set permissions for generated .ghci script [#1480](https://github.com/commercialhaskell/stack/issues/1480) * Restrict commands allowed in interpreter mode [#1504](https://github.com/commercialhaskell/stack/issues/1504) * stack ghci doesn't see preprocessed files for executables [#1347](https://github.com/commercialhaskell/stack/issues/1347) * All test suites run even when only one is requested [#1550](https://github.com/commercialhaskell/stack/pull/1550) * Edge cases in broken templates give odd errors [#1535](https://github.com/commercialhaskell/stack/issues/1535) * Fix test coverage bug on windows ## 0.1.10.1 Bug fixes: * `stack image container` did not actually build an image [#1473](https://github.com/commercialhaskell/stack/issues/1473) ## 0.1.10.0 Release notes: * The Stack home page is now at [haskellstack.org](http://haskellstack.org), which shows the documentation rendered by readthedocs.org. Note: this has necessitated some changes to the links in the documentation's markdown source code, so please check the links on the website before submitting a PR to fix them. * The locations of the [Ubuntu](http://docs.haskellstack.org/en/stable/install_and_upgrade/#ubuntu) and [Debian](http://docs.haskellstack.org/en/stable/install_and_upgrade/#debian) package repositories have changed to have correct URL semantics according to Debian's guidelines [#1378](https://github.com/commercialhaskell/stack/issues/1378). The old locations will continue to work for some months, but we suggest that you adjust your `/etc/apt/sources.list.d/fpco.list` to the new location to avoid future disruption. * [openSUSE and SUSE Linux Enterprise](http://docs.haskellstack.org/en/stable/install_and_upgrade/#suse) packages are now available, thanks to [@mimi1vx](https://github.com/mimi1vx). Note: there will be some lag before these pick up new versions, as they are based on Stackage LTS. Major changes: * Support for building inside a Nix-shell providing system dependencies [#1285](https://github.com/commercialhaskell/stack/pull/1285) * Add optional GPG signing on `stack upload --sign` or with `stack sig sign ...` Other enhancements: * Print latest applicable version of packages on conflicts [#508](https://github.com/commercialhaskell/stack/issues/508) * Support for packages located in Mercurial repositories [#1397](https://github.com/commercialhaskell/stack/issues/1397) * Only run benchmarks specified as build targets [#1412](https://github.com/commercialhaskell/stack/issues/1412) * Support git-style executable fall-through (`stack something` executes `stack-something` if present) [#1433](https://github.com/commercialhaskell/stack/issues/1433) * GHCi now loads intermediate dependencies [#584](https://github.com/commercialhaskell/stack/issues/584) * `--work-dir` option for overriding `.stack-work` [#1178](https://github.com/commercialhaskell/stack/issues/1178) * Support `detailed-0.9` tests [#1429](https://github.com/commercialhaskell/stack/issues/1429) * Docker: improved POSIX signal proxying to containers [#547](https://github.com/commercialhaskell/stack/issues/547) Bug fixes: * Show absolute paths in error messages in multi-package builds [#1348](https://github.com/commercialhaskell/stack/issues/1348) * Docker-built binaries and libraries in different path [#911](https://github.com/commercialhaskell/stack/issues/911) [#1367](https://github.com/commercialhaskell/stack/issues/1367) * Docker: `--resolver` argument didn't effect selected image tag * GHCi: Spaces in filepaths caused module loading issues [#1401](https://github.com/commercialhaskell/stack/issues/1401) * GHCi: cpp-options in cabal files weren't used [#1419](https://github.com/commercialhaskell/stack/issues/1419) * Benchmarks couldn't be run independently of each other [#1412](https://github.com/commercialhaskell/stack/issues/1412) * Send output of building setup to stderr [#1410](https://github.com/commercialhaskell/stack/issues/1410) ## 0.1.8.0 Major changes: * GHCJS can now be used with stackage snapshots via the new `compiler` field. * Windows installers are now available: [download them here](http://docs.haskellstack.org/en/stable/install_and_upgrade/#windows) [#613](https://github.com/commercialhaskell/stack/issues/613) * Docker integration works with non-FPComplete generated images [#531](https://github.com/commercialhaskell/stack/issues/531) Other enhancements: * Added an `allow-newer` config option [#922](https://github.com/commercialhaskell/stack/issues/922) [#770](https://github.com/commercialhaskell/stack/issues/770) * When a Hackage revision invalidates a build plan in a snapshot, trust the snapshot [#770](https://github.com/commercialhaskell/stack/issues/770) * Added a `stack config set resolver RESOLVER` command. Part of work on [#115](https://github.com/commercialhaskell/stack/issues/115) * `stack setup` can now install GHCJS on windows. See [#1145](https://github.com/commercialhaskell/stack/issues/1145) and [#749](https://github.com/commercialhaskell/stack/issues/749) * `stack hpc report` command added, which generates reports for HPC tix files * `stack ghci` now accepts all the flags accepted by `stack build`. See [#1186](https://github.com/commercialhaskell/stack/issues/1186) * `stack ghci` builds the project before launching GHCi. If the build fails, try to launch GHCi anyway. Use `stack ghci --no-build` option to disable [#1065](https://github.com/commercialhaskell/stack/issues/1065) * `stack ghci` now detects and warns about various circumstances where it is liable to fail. See [#1270](https://github.com/commercialhaskell/stack/issues/1270) * Added `require-docker-version` configuration option * Packages will now usually be built along with their tests and benchmarks. See [#1166](https://github.com/commercialhaskell/stack/issues/1166) * Relative `local-bin-path` paths will be relative to the project's root directory, not the current working directory. [#1340](https://github.com/commercialhaskell/stack/issues/1340) * `stack clean` now takes an optional `[PACKAGE]` argument for use in multi-package projects. See [#583](https://github.com/commercialhaskell/stack/issues/583) * Ignore cabal_macros.h as a dependency [#1195](https://github.com/commercialhaskell/stack/issues/1195) * Pad timestamps and show local time in --verbose output [#1226](https://github.com/commercialhaskell/stack/issues/1226) * GHCi: Import all modules after loading them [#995](https://github.com/commercialhaskell/stack/issues/995) * Add subcommand aliases: `repl` for `ghci`, and `runhaskell` for `runghc` [#1241](https://github.com/commercialhaskell/stack/issues/1241) * Add typo recommendations for unknown package identifiers [#158](https://github.com/commercialhaskell/stack/issues/158) * Add `stack path --local-hpc-root` option * Overhaul dependencies' haddocks copying [#1231](https://github.com/commercialhaskell/stack/issues/1231) * Support for extra-package-dbs in 'stack ghci' [#1229](https://github.com/commercialhaskell/stack/pull/1229) * `stack new` disallows package names with "words" consisting solely of numbers [#1336](https://github.com/commercialhaskell/stack/issues/1336) * `stack build --fast` turns off optimizations * Show progress while downloading package index [#1223](https://github.com/commercialhaskell/stack/issues/1223). Bug fixes: * Fix: Haddocks not copied for dependencies [#1105](https://github.com/commercialhaskell/stack/issues/1105) * Fix: Global options did not work consistently after subcommand [#519](https://github.com/commercialhaskell/stack/issues/519) * Fix: 'stack ghci' doesn't notice that a module got deleted [#1180](https://github.com/commercialhaskell/stack/issues/1180) * Rebuild when cabal file is changed * Fix: Paths in GHC warnings not canonicalized, nor those for packages in subdirectories or outside the project root [#1259](https://github.com/commercialhaskell/stack/issues/1259) * Fix: unlisted files in tests and benchmarks trigger extraneous second build [#838](https://github.com/commercialhaskell/stack/issues/838) ## 0.1.6.0 Major changes: * `stack setup` now supports building and booting GHCJS from source tarball. * On Windows, build directories no longer display "pretty" information (like x86_64-windows/Cabal-1.22.4.0), but rather a hash of that content. The reason is to avoid the 260 character path limitation on Windows. See [#1027](https://github.com/commercialhaskell/stack/pull/1027) * Rename config files and clarify their purposes [#969](https://github.com/commercialhaskell/stack/issues/969) * `~/.stack/stack.yaml` --> `~/.stack/config.yaml` * `~/.stack/global` --> `~/.stack/global-project` * `/etc/stack/config` --> `/etc/stack/config.yaml` * Old locations still supported, with deprecation warnings * New command "stack eval CODE", which evaluates to "stack exec ghc -- -e CODE". Other enhancements: * No longer install `git` on Windows [#1046](https://github.com/commercialhaskell/stack/issues/1046). You can still get this behavior by running the following yourself: `stack exec -- pacman -Sy --noconfirm git`. * Typing enter during --file-watch triggers a rebuild [#1023](https://github.com/commercialhaskell/stack/pull/1023) * Use Haddock's `--hyperlinked-source` (crosslinked source), if available [#1070](https://github.com/commercialhaskell/stack/pull/1070) * Use Stack-installed GHCs for `stack init --solver` [#1072](https://github.com/commercialhaskell/stack/issues/1072) * New experimental `stack query` command [#1087](https://github.com/commercialhaskell/stack/issues/1087) * By default, stack no longer rebuilds a package due to GHC options changes. This behavior can be tweaked with the `rebuild-ghc-options` setting. [#1089](https://github.com/commercialhaskell/stack/issues/1089) * By default, ghc-options are applied to all local packages, not just targets. This behavior can be tweaked with the `apply-ghc-options` setting. [#1089](https://github.com/commercialhaskell/stack/issues/1089) * Docker: download or override location of stack executable to re-run in container [#974](https://github.com/commercialhaskell/stack/issues/974) * Docker: when Docker Engine is remote, don't run containerized processes as host's UID/GID [#194](https://github.com/commercialhaskell/stack/issues/194) * Docker: `set-user` option to enable/disable running containerized processes as host's UID/GID [#194](https://github.com/commercialhaskell/stack/issues/194) * Custom Setup.hs files are now precompiled instead of interpreted. This should be a major performance win for certain edge cases (biggest example: [building Cabal itself](https://github.com/commercialhaskell/stack/issues/1041)) while being either neutral or a minor slowdown for more common cases. * `stack test --coverage` now also generates a unified coverage report for multiple test-suites / packages. In the unified report, test-suites can contribute to the coverage of other packages. Bug fixes: * Ignore stack-built executables named `ghc` [#1052](https://github.com/commercialhaskell/stack/issues/1052) * Fix quoting of output failed command line arguments * Mark executable-only packages as installed when copied from cache [#1043](https://github.com/commercialhaskell/stack/pull/1043) * Canonicalize temporary directory paths [#1047](https://github.com/commercialhaskell/stack/pull/1047) * Put code page fix inside the build function itself [#1066](https://github.com/commercialhaskell/stack/issues/1066) * Add `explicit-setup-deps` option [#1110](https://github.com/commercialhaskell/stack/issues/1110), and change the default to the old behavior of using any package in the global and snapshot database [#1025](https://github.com/commercialhaskell/stack/issues/1025) * Precompiled cache checks full package IDs on Cabal < 1.22 [#1103](https://github.com/commercialhaskell/stack/issues/1103) * Pass -package-id to ghci [#867](https://github.com/commercialhaskell/stack/issues/867) * Ignore global packages when copying precompiled packages [#1146](https://github.com/commercialhaskell/stack/issues/1146) ## 0.1.5.0 Major changes: * On Windows, we now use a full MSYS2 installation in place of the previous PortableGit. This gives you access to the pacman package manager for more easily installing libraries. * Support for custom GHC binary distributions [#530](https://github.com/commercialhaskell/stack/issues/530) * `ghc-variant` option in stack.yaml to specify the variant (also `--ghc-variant` command-line option) * `setup-info` in stack.yaml, to specify where to download custom binary distributions (also `--ghc-bindist` command-line option) * Note: On systems with libgmp4 (aka `libgmp.so.3`), such as CentOS 6, you may need to re-run `stack setup` due to the centos6 GHC bindist being treated like a variant * A new `--pvp-bounds` flag to the sdist and upload commands allows automatic adding of PVP upper and/or lower bounds to your dependencies Other enhancements: * Adapt to upcoming Cabal installed package identifier format change [#851](https://github.com/commercialhaskell/stack/issues/851) * `stack setup` takes a `--stack-setup-yaml` argument * `--file-watch` is more discerning about which files to rebuild for [#912](https://github.com/commercialhaskell/stack/issues/912) * `stack path` now supports `--global-pkg-db` and `--ghc-package-path` * `--reconfigure` flag [#914](https://github.com/commercialhaskell/stack/issues/914) [#946](https://github.com/commercialhaskell/stack/issues/946) * Cached data is written with a checksum of its structure [#889](https://github.com/commercialhaskell/stack/issues/889) * Fully removed `--optimizations` flag * Added `--cabal-verbose` flag * Added `--file-watch-poll` flag for polling instead of using filesystem events (useful for running tests in a Docker container while modifying code in the host environment. When code is injected into the container via a volume, the container won't propagate filesystem events). * Give a preemptive error message when `-prof` is given as a GHC option [#1015](https://github.com/commercialhaskell/stack/issues/1015) * Locking is now optional, and will be turned on by setting the `STACK_LOCK` environment variable to `true` [#950](https://github.com/commercialhaskell/stack/issues/950) * Create default stack.yaml with documentation comments and commented out options [#226](https://github.com/commercialhaskell/stack/issues/226) * Out of memory warning if Cabal exits with -9 [#947](https://github.com/commercialhaskell/stack/issues/947) Bug fixes: * Hacky workaround for optparse-applicative issue with `stack exec --help` [#806](https://github.com/commercialhaskell/stack/issues/806) * Build executables for local extra deps [#920](https://github.com/commercialhaskell/stack/issues/920) * copyFile can't handle directories [#942](https://github.com/commercialhaskell/stack/pull/942) * Support for spaces in Haddock interface files [fpco/minghc#85](https://github.com/fpco/minghc/issues/85) * Temporarily building against a "shadowing" local package? [#992](https://github.com/commercialhaskell/stack/issues/992) * Fix Setup.exe name for --upgrade-cabal on Windows [#1002](https://github.com/commercialhaskell/stack/issues/1002) * Unlisted dependencies no longer trigger extraneous second build [#838](https://github.com/commercialhaskell/stack/issues/838) ## 0.1.4.1 Fix stack's own Haddocks. No changes to functionality (only comments updated). ## 0.1.4.0 Major changes: * You now have more control over how GHC versions are matched, e.g. "use exactly this version," "use the specified minor version, but allow patches," or "use the given minor version or any later minor in the given major release." The default has switched from allowing newer later minor versions to a specific minor version allowing patches. For more information, see [#736](https://github.com/commercialhaskell/stack/issues/736) and [#784](https://github.com/commercialhaskell/stack/pull/784). * Support added for compiling with GHCJS * stack can now reuse prebuilt binaries between snapshots. That means that, if you build package foo in LTS-3.1, that binary version can be reused in LTS-3.2, assuming it uses the same dependencies and flags. [#878](https://github.com/commercialhaskell/stack/issues/878) Other enhancements: * Added the `--docker-env` argument, to set environment variables in Docker container. * Set locale environment variables to UTF-8 encoding for builds to avoid "commitBuffer: invalid argument" errors from GHC [#793](https://github.com/commercialhaskell/stack/issues/793) * Enable transliteration for encoding on stdout and stderr [#824](https://github.com/commercialhaskell/stack/issues/824) * By default, `stack upgrade` automatically installs GHC as necessary [#797](https://github.com/commercialhaskell/stack/issues/797) * Added the `ghc-options` field to stack.yaml [#796](https://github.com/commercialhaskell/stack/issues/796) * Added the `extra-path` field to stack.yaml * Code page changes on Windows only apply to the build command (and its synonyms), and can be controlled via a command line flag (still defaults to on) [#757](https://github.com/commercialhaskell/stack/issues/757) * Implicitly add packages to extra-deps when a flag for them is set [#807](https://github.com/commercialhaskell/stack/issues/807) * Use a precompiled Setup.hs for simple build types [#801](https://github.com/commercialhaskell/stack/issues/801) * Set --enable-tests and --enable-benchmarks optimistically [#805](https://github.com/commercialhaskell/stack/issues/805) * `--only-configure` option added [#820](https://github.com/commercialhaskell/stack/issues/820) * Check for duplicate local package names * Stop nagging people that call `stack test` [#845](https://github.com/commercialhaskell/stack/issues/845) * `--file-watch` will ignore files that are in your VCS boring/ignore files [#703](https://github.com/commercialhaskell/stack/issues/703) * Add `--numeric-version` option Bug fixes: * `stack init --solver` fails if `GHC_PACKAGE_PATH` is present [#860](https://github.com/commercialhaskell/stack/issues/860) * `stack solver` and `stack init --solver` check for test suite and benchmark dependencies [#862](https://github.com/commercialhaskell/stack/issues/862) * More intelligent logic for setting UTF-8 locale environment variables [#856](https://github.com/commercialhaskell/stack/issues/856) * Create missing directories for `stack sdist` * Don't ignore .cabal files with extra periods [#895](https://github.com/commercialhaskell/stack/issues/895) * Deprecate unused `--optimizations` flag * Truncated output on slow terminals [#413](https://github.com/commercialhaskell/stack/issues/413) ## 0.1.3.1 Bug fixes: * Ignore disabled executables [#763](https://github.com/commercialhaskell/stack/issues/763) ## 0.1.3.0 Major changes: * Detect when a module is compiled but not listed in the cabal file ([#32](https://github.com/commercialhaskell/stack/issues/32)) * A warning is displayed for any modules that should be added to `other-modules` in the .cabal file * These modules are taken into account when determining whether a package needs to be built * Respect TemplateHaskell addDependentFile dependency changes ([#105](https://github.com/commercialhaskell/stack/issues/105)) * TH dependent files are taken into account when determining whether a package needs to be built. * Overhauled target parsing, added `--test` and `--bench` options [#651](https://github.com/commercialhaskell/stack/issues/651) * For details, see [Build commands documentation](http://docs.haskellstack.org/en/stable/build_command/) Other enhancements: * Set the `HASKELL_DIST_DIR` environment variable [#524](https://github.com/commercialhaskell/stack/pull/524) * Track build status of tests and benchmarks [#525](https://github.com/commercialhaskell/stack/issues/525) * `--no-run-tests` [#517](https://github.com/commercialhaskell/stack/pull/517) * Targets outside of root dir don't build [#366](https://github.com/commercialhaskell/stack/issues/366) * Upper limit on number of flag combinations to test [#543](https://github.com/commercialhaskell/stack/issues/543) * Fuzzy matching support to give better error messages for close version numbers [#504](https://github.com/commercialhaskell/stack/issues/504) * `--local-bin-path` global option. Use to change where binaries get placed on a `--copy-bins` [#342](https://github.com/commercialhaskell/stack/issues/342) * Custom snapshots [#111](https://github.com/commercialhaskell/stack/issues/111) * --force-dirty flag: Force treating all local packages as having dirty files (useful for cases where stack can't detect a file change) * GHC error messages: display file paths as absolute instead of relative for better editor integration * Add the `--copy-bins` option [#569](https://github.com/commercialhaskell/stack/issues/569) * Give warnings on unexpected config keys [#48](https://github.com/commercialhaskell/stack/issues/48) * Remove Docker `pass-host` option * Don't require cabal-install to upload [#313](https://github.com/commercialhaskell/stack/issues/313) * Generate indexes for all deps and all installed snapshot packages [#143](https://github.com/commercialhaskell/stack/issues/143) * Provide `--resolver global` option [#645](https://github.com/commercialhaskell/stack/issues/645) * Also supports `--resolver nightly`, `--resolver lts`, and `--resolver lts-X` * Make `stack build --flag` error when flag or package is unknown [#617](https://github.com/commercialhaskell/stack/issues/617) * Preserve file permissions when unpacking sources [#666](https://github.com/commercialhaskell/stack/pull/666) * `stack build` etc work outside of a project * `list-dependencies` command [#638](https://github.com/commercialhaskell/stack/issues/638) * `--upgrade-cabal` option to `stack setup` [#174](https://github.com/commercialhaskell/stack/issues/174) * `--exec` option [#651](https://github.com/commercialhaskell/stack/issues/651) * `--only-dependencies` implemented correctly [#387](https://github.com/commercialhaskell/stack/issues/387) Bug fixes: * Extensions from the `other-extensions` field no longer enabled by default [#449](https://github.com/commercialhaskell/stack/issues/449) * Fix: haddock forces rebuild of empty packages [#452](https://github.com/commercialhaskell/stack/issues/452) * Don't copy over executables excluded by component selection [#605](https://github.com/commercialhaskell/stack/issues/605) * Fix: stack fails on Windows with git package in stack.yaml and no git binary on path [#712](https://github.com/commercialhaskell/stack/issues/712) * Fixed GHCi issue: Specifying explicit package versions (#678) * Fixed GHCi issue: Specifying -odir and -hidir as .stack-work/odir (#529) * Fixed GHCi issue: Specifying A instead of A.ext for modules (#498) ## 0.1.2.0 * Add `--prune` flag to `stack dot` [#487](https://github.com/commercialhaskell/stack/issues/487) * Add `--[no-]external`,`--[no-]include-base` flags to `stack dot` [#437](https://github.com/commercialhaskell/stack/issues/437) * Add `--ignore-subdirs` flag to init command [#435](https://github.com/commercialhaskell/stack/pull/435) * Handle attempt to use non-existing resolver [#436](https://github.com/commercialhaskell/stack/pull/436) * Add `--force` flag to `init` command * exec style commands accept the `--package` option (see [Reddit discussion](http://www.reddit.com/r/haskell/comments/3bd66h/stack_runghc_turtle_as_haskell_script_solution/)) * `stack upload` without arguments doesn't do anything [#439](https://github.com/commercialhaskell/stack/issues/439) * Print latest version of packages on conflicts [#450](https://github.com/commercialhaskell/stack/issues/450) * Flag to avoid rerunning tests that haven't changed [#451](https://github.com/commercialhaskell/stack/issues/451) * stack can act as a script interpreter (see [Script interpreter] (https://github.com/commercialhaskell/stack/wiki/Script-interpreter) and [Reddit discussion](http://www.reddit.com/r/haskell/comments/3bd66h/stack_runghc_turtle_as_haskell_script_solution/)) * Add the __`--file-watch`__ flag to auto-rebuild on file changes [#113](https://github.com/commercialhaskell/stack/issues/113) * Rename `stack docker exec` to `stack exec --plain` * Add the `--skip-msys` flag [#377](https://github.com/commercialhaskell/stack/issues/377) * `--keep-going`, turned on by default for tests and benchmarks [#478](https://github.com/commercialhaskell/stack/issues/478) * `concurrent-tests: BOOL` [#492](https://github.com/commercialhaskell/stack/issues/492) * Use hashes to check file dirtiness [#502](https://github.com/commercialhaskell/stack/issues/502) * Install correct GHC build on systems with libgmp.so.3 [#465](https://github.com/commercialhaskell/stack/issues/465) * `stack upgrade` checks version before upgrading [#447](https://github.com/commercialhaskell/stack/issues/447) ## 0.1.1.0 * Remove GHC uncompressed tar file after installation [#376](https://github.com/commercialhaskell/stack/issues/376) * Put stackage snapshots JSON on S3 [#380](https://github.com/commercialhaskell/stack/issues/380) * Specifying flags for multiple packages [#335](https://github.com/commercialhaskell/stack/issues/335) * single test suite failure should show entire log [#388](https://github.com/commercialhaskell/stack/issues/388) * valid-wanted is a confusing option name [#386](https://github.com/commercialhaskell/stack/issues/386) * stack init in multi-package project should use local packages for dependency checking [#384](https://github.com/commercialhaskell/stack/issues/384) * Display information on why a snapshot was rejected [#381](https://github.com/commercialhaskell/stack/issues/381) * Give a reason for unregistering packages [#389](https://github.com/commercialhaskell/stack/issues/389) * `stack exec` accepts the `--no-ghc-package-path` parameter * Don't require build plan to upload [#400](https://github.com/commercialhaskell/stack/issues/400) * Specifying test components only builds/runs those tests [#398](https://github.com/commercialhaskell/stack/issues/398) * `STACK_EXE` environment variable * Add the `stack dot` command * `stack upgrade` added [#237](https://github.com/commercialhaskell/stack/issues/237) * `--stack-yaml` command line flag [#378](https://github.com/commercialhaskell/stack/issues/378) * `--skip-ghc-check` command line flag [#423](https://github.com/commercialhaskell/stack/issues/423) Bug fixes: * Haddock links to global packages no longer broken on Windows [#375](https://github.com/commercialhaskell/stack/issues/375) * Make flags case-insensitive [#397](https://github.com/commercialhaskell/stack/issues/397) * Mark packages uninstalled before rebuilding [#365](https://github.com/commercialhaskell/stack/issues/365) ## 0.1.0.0 * Fall back to cabal dependency solver when a snapshot can't be found * Basic implementation of `stack new` [#137](https://github.com/commercialhaskell/stack/issues/137) * `stack solver` command [#364](https://github.com/commercialhaskell/stack/issues/364) * `stack path` command [#95](https://github.com/commercialhaskell/stack/issues/95) * Haddocks [#143](https://github.com/commercialhaskell/stack/issues/143): * Build for dependencies * Use relative links * Generate module contents and index for all packages in project ## 0.0.3 * `--prefetch` [#297](https://github.com/commercialhaskell/stack/issues/297) * `upload` command ported from stackage-upload [#225](https://github.com/commercialhaskell/stack/issues/225) * `--only-snapshot` [#310](https://github.com/commercialhaskell/stack/issues/310) * `--resolver` [#224](https://github.com/commercialhaskell/stack/issues/224) * `stack init` [#253](https://github.com/commercialhaskell/stack/issues/253) * `--extra-include-dirs` and `--extra-lib-dirs` [#333](https://github.com/commercialhaskell/stack/issues/333) * Specify intra-package target [#201](https://github.com/commercialhaskell/stack/issues/201) ## 0.0.2 * Fix some Windows specific bugs [#216](https://github.com/commercialhaskell/stack/issues/216) * Improve output for package index updates [#227](https://github.com/commercialhaskell/stack/issues/227) * Automatically update indices as necessary [#227](https://github.com/commercialhaskell/stack/issues/227) * --verbose flag [#217](https://github.com/commercialhaskell/stack/issues/217) * Remove packages (HTTPS and Git) [#199](https://github.com/commercialhaskell/stack/issues/199) * Config values for system-ghc and install-ghc * Merge `stack deps` functionality into `stack build` * `install` command [#153](https://github.com/commercialhaskell/stack/issues/153) and [#272](https://github.com/commercialhaskell/stack/issues/272) * overriding architecture value (useful to force 64-bit GHC on Windows, for example) * Overhauled test running (allows cycles, avoids unnecessary recompilation, etc) ## 0.0.1 * First public release, beta quality stack-1.9.3.1/doc/CONTRIBUTING.md0000644000000000000000000001422613455617610014171 0ustar0000000000000000# Contributors Guide ## Bug Reports Please [open an issue](https://github.com/commercialhaskell/stack/issues/new) and use the provided template to include all necessary details. The more detailed your report, the faster it can be resolved and will ensure it is resolved in the right way. Once your bug has been resolved, the responsible person will tag the issue as _Needs confirmation_ and assign the issue back to you. Once you have tested and confirmed that the issue is resolved, close the issue. If you are not a member of the project, you will be asked for confirmation and we will close it. ## Documentation If you would like to help with documentation, please note that for most cases the Wiki has been deprecated in favor of markdown files placed in a new `/doc` subdirectory of the repository itself. Please submit a [pull request](https://help.github.com/articles/using-pull-requests/) with your changes/additions based off the [the stable branch](https://github.com/commercialhaskell/stack/tree/stable). The documentation is rendered on [haskellstack.org](http://haskellstack.org) by readthedocs.org using Sphinx and CommonMark. Since links and formatting vary from GFM, please check the documentation there before submitting a PR to fix those. If your changes move or rename files, or subsume Wiki content, please continue to leave a file/page in the old location temporarily, in addition to the new location. This will allow users time to update any shared links to the old location. Please also update any links in other files, or on the Wiki, to point to the new file location. ## Code If you would like to contribute code to fix a bug, add a new feature, or otherwise improve `stack`, pull requests are most welcome. It's a good idea to [submit an issue](https://github.com/commercialhaskell/stack/issues/new) to discuss the change before plowing into writing code. If you'd like to help out but aren't sure what to work on, look for issues with the [awaiting pull request](https://github.com/commercialhaskell/stack/issues?q=is%3Aopen+is%3Aissue+label%3A%22awaiting+pull+request%22) label. Issues that are suitable for newcomers to the codebase have the [newcomer friendly](https://github.com/commercialhaskell/stack/issues?q=is%3Aopen+is%3Aissue+label%3A%22awaiting+pull+request%22+label%3a%22newcomer+friendly%22) label. Best to post a comment to the issue before you start work, in case anyone has already started. Please include a [ChangeLog](https://github.com/commercialhaskell/stack/blob/master/ChangeLog.md) entry and [documentation](https://github.com/commercialhaskell/stack/tree/master/doc/) updates with your pull request. ## Code Quality The Stack projects uses [HLint](https://github.com/ndmitchell/hlint) as a code quality tool. Note that stack contributors need not dogmatically follow the suggested hints but are encouraged to debate their usefulness. If you find a hint is not useful and detracts from readability, consider marking it in the [configuration file](https://github.com/commercialhaskell/stack/blob/master/.hlint.yaml) to be ignored. Please refer to the [HLint manual](https://github.com/ndmitchell/hlint#readme) for configuration syntax. Quoting [@mgsloan](https://github.com/commercialhaskell/stack/pulls?utf8=%E2%9C%93&q=is%3Apr%20author%3Amgsloan): > We are optimizing for code clarity, not code concision or what HLint thinks. You can install HLint with stack. You might want to install it in the global project in case you run into dependency conflicts. HLint can report hints in your favourite text editor. Refer to the HLint repository for more details. To install: ``` stack install hlint ``` Once installed, you can check your changes with: ``` $ ./etc/scripts/hlint.sh ``` ## Testing The Stack code has both unit tests and integration tests. Integration tests can be found in the [test/integration](https://github.com/commercialhaskell/stack/tree/master/test/integration) folder and unit tests, in the [src/test](https://github.com/commercialhaskell/stack/tree/master/src/test) folder. Tests are written using the [Hspec](https://hspec.github.io/) framework. In order to run the full test suite, you can simply do: ```bash $ stack test ``` The `--file-watch` is a very useful option to get quick feedback. However, running the entire test suite after each file change will slow you down. You'll need to specify which test suite (unit test or integration) and pass arguments to specify which module you'd specifically like to run to get quick feedback. A description of this follows below. ### Working with Unit Tests If you would like to run the unit tests on their own, you can: ```bash $ stack test stack:stack-test ``` Running an individual module works like this: ```bash $ stack test stack:stack-test --ta "-m " ``` Where `` is the name of the module without `Spec.hs`. You may also load tests into GHCi and run them with: ```bash $ stack ghci stack:stack-test --only-main # GHCi starting up output ... > :main -m "" ``` Where again, `` is the name of the module without `Spec.hs`. ### Working with Integration Tests Running the integration tests is a little involved, you'll need to: ```bash $ stack test stack:stack-integration-test --flag stack:integration-tests ``` Running an individual module works like this: ```bash $ stack test stack:stack-integration-test --flag stack:integration-tests --ta "-m " ``` Where `` is the name of the folder listed in the [test/integration/tests/](https://github.com/commercialhaskell/stack/tree/master/test/integration/tests) folder. You may also achieve this through GHCi with: ```bash $ stack ghci stack:stack-integration-test # GHCi starting up output ... > :main -m "" ``` Where again, `` is the name of the folder listed in the [test/integration/tests/](https://github.com/commercialhaskell/stack/tree/master/test/integration/tests) folder. ## Slack channel If you're making deep changes and real-time communcation with the Stack team would be helpful, we have a `#stack-collaborators` Slack channel. Please contact [@borsboom](https://github.com/borsboom) (manny@fpcomplete.com) or [@snoyberg](https://github.com/snoyberg) (michael@fpcomplete.com) for an invite. stack-1.9.3.1/doc/coverage.md0000644000000000000000000001263413455666157014070 0ustar0000000000000000
# Code Coverage Code coverage is enabled by passing the `--coverage` flag to `stack build`. ## Usage `stack test --coverage` is quite streamlined for the following use-case: 1. You have test-suites which exercise your local packages. 2. These test-suites link against your library, rather than building the library directly. Coverage information is only given for libraries, ignoring the modules which get compiled directly into your executable. A common case where this doesn't happen is when your test-suite and library both have something like `hs-source-dirs: src/`. In this case, when building your test-suite you may also be compiling your library, instead of just linking against it. When your project has these properties, you will get the following: 1) Textual coverage reports in the build output. 2) A unified textual and HTML report, considering the coverage on all local libraries, based on all of the tests that were run. 3) An index of all generated HTML reports, at `$(stack path --local-hpc-root)/index.html`. ## "stack hpc report" command The `stack hpc report` command generates a report for a selection of targets and `.tix` files. For example, if we have 3 different packages with test-suites, packages `A`, `B`, and `C`, the default unified report will have coverage from all 3. If we want a unified report with just two, we can instead run: ``` $ stack hpc report A B ``` This will output a textual report for the combined coverage from `A` and `B`'s test-suites, along with a path to the HTML for the report. To further streamline this process, you can pass the `--open` option, to open the report in your browser. This command also supports taking extra `.tix` files. If you've also built an executable, against exactly the same library versions of `A`, `B`, and `C`, then you could do the following: ``` $ stack exec -- an-exe $ stack hpc report A B C an-exe.tix ``` This report will consider all test results as well as the newly generated `an-exe.tix` file. Since this is a common use-case, there is a convenient flag to use all stored results - `stack hpc report --all an-exe.tix`. ## "extra-tix-files" directory During the execution of the build, you can place additional tix files in `$(stack path --local-hpc-root)/extra-tix-files/` in order for them to be included in the unified report. A couple caveats: * These tix files must be generated by executables that are built against the exact same library versions. Also note that, on subsequent builds with coverage, the `$(stack path --local-hpc-root)` directory will be recursively deleted. It just stores the most recent coverage data. * These tix files will not be considered by `stack hpc report` unless listed explicitly by file name. ## Implementation details Most users can get away with just understanding the above documentation. However, advanced users may want to understand exactly how `--coverage` works: 1. The GHC option `-fhpc` gets passed to all local packages. This tells GHC to output executables that track coverage information and output them to `.tix` files. `the-exe-name.tix` files will get written to the working directory of the executable. When switching on this flag, it will usually cause all local packages to be rebuilt (see [#1940](https://github.com/commercialhaskell/stack/issues/1940). 2. Before the build runs with `--coverage`, the contents of `stack path --local-hpc-root` gets deleted. This prevents old reports from getting mixed with new reports. If you want to preserve report information from multiple runs, copy the contents of this path to a new folder. 3. Before a test run, if a `test-name.tix` file exists in the package directory, it will be deleted. 4. After a test run, it will expect a `test-name.tix` file to exist. This file will then get loaded, modified, and outputted to `$(stack path --local-hpc-root)/pkg-name/test-name/test-name.tix)`. The `.tix` file gets modified to remove coverage file that isn't associated with a library. So, this means that you won't get coverage information for the modules compiled in the `executable` or `test-suite` stanza of your cabal file. This makes it possible to directly union multiple `*.tix` files from different executables (assuming they are using the exact same versions of the local packages). If there is enough popular demand, it may be possible in the future to give coverage information for modules that are compiled directly into the executable. See [#1359](https://github.com/commercialhaskell/stack/issues/1359). 5. Once we have a `.tix` file for a test, we also generate a textual and HTML report for it. The textual report is sent to the terminal. The index of the test-specific HTML report is available at `$(stack path --local-hpc-root)/pkg-name/test-name/index.html` 6. After the build completes, if there are multiple output `*.tix` files, they get combined into a unified report. The index of this report will be available at `$(stack path --local-hpc-root)/combined/all/index.html` 7. Finally, an index of the resulting coverage reports is generated. It links to the individual coverage reports (one for each test-suite), as well as the unified report. This index is available at `$(stack path --local-hpc-root)/index.html` stack-1.9.3.1/doc/custom_snapshot.md0000644000000000000000000001013513455666157015520 0ustar0000000000000000
# Custom Snapshots Custom snapshots were totally reworked with the extensible snapshots overhaul in Stack 1.6.0, see [the writeup](https://www.fpcomplete.com/blog/2017/07/stacks-new-extensible-snapshots) and [PR #3249](https://github.com/commercialhaskell/stack/pull/3249)). This documentation covers the new syntax only. Custom snapshots allow you to create your own snapshots, which provide a list of packages to use, along with flags, ghc-options, and a few other settings. Custom snapshots may extend any other snapshot that can be specified in a `resolver` field. The packages specified follow the syntax of `extra-deps` in the `stack.yaml` file, with one exception: to ensure reproducibility of snapshots, local directories are not allowed for custom snapshots (as they are expected to change regularly). ```yaml resolver: lts-8.21 # Inherits GHC version and package set compiler: ghc-8.0.1 # Overwrites GHC version in the resolver, optional name: my-snapshot # User-friendly name # Additional packages, follows extra-deps syntax packages: - unordered-containers-0.2.7.1 - hashable-1.2.4.0 - text-1.2.2.1 # Override flags, can also override flags in the parent snapshot flags: unordered-containers: debug: true # Packages from the parent snapshot to ignore drop-packages: - wai-extra # Packages which should be hidden (affects script command's import # parser hidden: wai: true warp: false # Set GHC options for specific packages ghc-options: warp: - -O2 ``` If you put this in a `snapshot.yaml` file in the same directory as your project, you can now use the custom snapshot like this: ```yaml resolver: snapshot.yaml ``` This is an example of a custom snapshot stored in the filesystem. They are assumed to be mutable, so you are free to modify it. We detect that the snapshot has changed by hashing the contents of the involved files, and using it to identify the snapshot internally. It is often reasonably efficient to modify a custom snapshot, due to stack sharing snapshot packages whenever possible. ## Using a URL instead of a filepath For efficiency, URLs are treated differently. If I uploaded the snapshot to `https://domain.org/snapshot-1.yaml`, it is expected to be immutable. If you change that file, then you lose any reproducibility guarantees. ### Overriding the compiler The following snapshot specification will be identical to `lts-7.1`, but instead use `ghc-7.10.3` instead of `ghc-8.0.1`: ```yaml resolver: lts-7.1 compiler: ghc-7.10.3 ``` ### Dropping packages The following snapshot specification will be identical to `lts-7.1`, but without the `text` package in our snapshot. Removing this package will cause all the packages that depend on `text` to be unbuildable, but they will still be present in the snapshot. ```yaml resolver: lts-7.1 drop-packages: - text ``` ### Specifying ghc-options In order to specify ghc-options for a package, you use the same syntax as the [ghc-options](yaml_configuration.md#ghc-options) field for build configuration. The following snapshot specification will be identical to `lts-7.1`, but provides `-O1` as a ghc-option for `text`: ```yaml resolver: lts-7.1 packages: - text-1.2.2.1 ghc-options: text: -O1 ``` This works somewhat differently than the stack.yaml `ghc-options` field, in that options can only be specified for packages that are mentioned in the custom snapshot's `packages` list. It sets the ghc-options, rather than extending those specified in the snapshot being extended. Another difference is that the `*` entry for `ghc-options` applies to all packages in the `packages` list, rather than all packages in the snapshot. ### Specifying flags In order to specify flags for a package, you use the same syntax as the [flags](yaml_configuration.md#flags) field for build configuration. The following snapshot specification will be identical to `lts-7.1`, but it enables the `developer` cabal flag: ```yaml resolver: lts-7.1 packages: - text-1.2.2.1 flags: text: developer: true ``` stack-1.9.3.1/doc/dependency_visualization.md0000644000000000000000000000536113455666157017373 0ustar0000000000000000
# Dependency visualization You can use stack to visualize the dependencies between your packages and optionally also external dependencies. As an example, let's look at `wreq`: ``` $ stack dot | dot -Tpng -o wreq.png ``` [![wreq](https://cloud.githubusercontent.com/assets/591567/8478591/ae10a418-20d2-11e5-8945-55246dcfac62.png)](https://cloud.githubusercontent.com/assets/591567/8478591/ae10a418-20d2-11e5-8945-55246dcfac62.png) Okay that is a little boring, let's also look at external dependencies: ``` $ stack dot --external | dot -Tpng -o wreq.png ``` [![wreq_ext](https://cloud.githubusercontent.com/assets/591567/8478621/d247247e-20d2-11e5-993d-79096e382abd.png)](https://cloud.githubusercontent.com/assets/591567/8478621/d247247e-20d2-11e5-993d-79096e382abd.png) Well that is certainly a lot. As a start we can exclude `base` and then depending on our needs we can either limit the depth: ``` $ stack dot --no-include-base --external --depth 1 | dot -Tpng -o wreq.png ``` [![wreq_depth](https://cloud.githubusercontent.com/assets/591567/8484310/45b399a0-20f7-11e5-8068-031c2b352961.png)](https://cloud.githubusercontent.com/assets/591567/8484310/45b399a0-20f7-11e5-8068-031c2b352961.png) or prune packages explicitly: ``` $ stack dot --external --prune base,lens,wreq-examples,http-client,aeson,tls,http-client-tls,exceptions | dot -Tpng -o wreq_pruned.png ``` [![wreq_pruned](https://cloud.githubusercontent.com/assets/591567/8478768/adbad280-20d3-11e5-9992-914dc24fe569.png)](https://cloud.githubusercontent.com/assets/591567/8478768/adbad280-20d3-11e5-9992-914dc24fe569.png) Keep in mind that you can also save the dot file: ``` $ stack dot --external --depth 1 > wreq.dot $ dot -Tpng -o wreq.png wreq.dot ``` and pass in options to `dot` or use another graph layout engine like `twopi`: ``` $ stack dot --external --prune base,lens,wreq-examples,http-client,aeson,tls,http-client-tls,exceptions | twopi -Groot=wreq -Goverlap=false -Tpng -o wreq_pruned.png ``` [![wreq_pruned](https://cloud.githubusercontent.com/assets/591567/8495538/9fae1184-216e-11e5-9931-99e6147f8aed.png)](https://cloud.githubusercontent.com/assets/591567/8495538/9fae1184-216e-11e5-9931-99e6147f8aed.png) ## Specifying local targets and flags The `dot` and `list-dependencies` commands both also accept the following options which affect how local packages are considered: * `TARGET`, same as the targets passed to `build` * `--test`, specifying that test components should be considered * `--bench`, specifying that benchmark components should be considered * `--flag`, specifying flags which may affect cabal file `build-depends` stack-1.9.3.1/doc/docker_integration.md0000644000000000000000000005300113455666157016140 0ustar0000000000000000
Docker integration =============================================================================== **Note:** This page is mainly about building Haskell packages inside docker containers. If you want to deploy your built Haskell programs into a docker container, look [here](GUIDE.md#docker) instead. `stack` has support for automatically performing builds inside a Docker container, using volume mounts and user ID switching to make it mostly seamless. FP Complete provides images for use with stack that include GHC, tools, and optionally have all of the Stackage LTS packages pre-installed in the global package database. The primary purpose for using stack/docker this way is for teams to ensure all developers are building in an exactly consistent environment without team members needing to deal with Docker themselves. See the [how stack can use Docker under the hood](https://www.fpcomplete.com/blog/2015/08/stack-docker) blog post for more information about the motivation and implementation of stack's Docker support. Prerequisites ------------------------------------------------------------------------------- ### Supported operating systems **Linux 64-bit**: Docker use requires machine (virtual or metal) running a Linux distribution [that Docker supports](https://docs.docker.com/installation/#installation), with a 64-bit kernel. If you do not already have one, we suggest Ubuntu 14.04 ("trusty") since this is what we test with. **macOS**: [Docker for Mac](https://docs.docker.com/docker-for-mac/) is the supported way to use Docker integration on macOS (the older Docker Machine (boot2docker) approach to using Docker on macOS is not supported due to issues with host volume mounting that make Stack nearly unusable for anything but the most trivial projects). Other Un*xen are not officially supported but there are ways to get them working. See [#194](https://github.com/commercialhaskell/stack/issues/194) for details and workarounds. **Windows does not work at all** (see [#2421](https://github.com/commercialhaskell/stack/issues/2421)). ### Docker Install the latest version of Docker by following the [instructions for your operating system](http://docs.docker.com/installation/). The Docker client should be able to connect to the Docker daemon as a non-root user. For example (from [here](http://docs.docker.com/installation/ubuntulinux/#ubuntu-raring-1304-and-saucy-1310-64-bit)): # Add the connected user "${USER}" to the docker group. # Change the user name to match your preferred user. sudo gpasswd -a ${USER} docker # Restart the Docker daemon. sudo service docker restart You will now need to log out and log in again for the group addition to take effect. Note the above has security implications. See [security](#security) for more. Usage ------------------------------------------------------------------------------- This section assumes that you already have Docker installed and working. If not, see the [prerequisites](#prerequisites) section. If you run into any trouble, see the [troubleshooting](#troubleshooting) section. ### Enable in stack.yaml The most basic configuration is to add this to your project's `stack.yaml`: docker: enable: true See [configuration](#configuration) for additional options. You can enable it on the command-line using `stack --docker`. Please note that in a docker-enabled configuration, stack uses the GHC installed in the Docker container by default. To use a compiler installed by stack, add system-ghc: false (see [`system-ghc`](yaml_configuration.md#system-ghc)). ### Use stack as normal With Docker enabled, most stack sub-commands will automatically launch themselves in an ephemeral Docker container (the container is deleted as soon as the command completes). The project directory and `~/.stack` are volume-mounted into the container, so any build artifacts are "permanent" (not deleted with the container). The first time you run a command with a new image, you will be prompted to run `stack docker pull` to pull the image first. This will pull a Docker image with a tag that matches your resolver. Only LTS resolvers are supported (we do not generate images for nightly snapshots). Not every LTS version is guaranteed to have an image existing, and new LTS images tend to lag behind the LTS snapshot being published on stackage.org. Be warned: these images are rather large! Docker sub-commands ------------------------------------------------------------------------------- These `stack docker` sub-commands have Docker-specific functionality. Most other `stack` commands will also use a Docker container under the surface if Docker is enabled. ### pull - Pull latest version of image `stack docker pull` pulls an image from the Docker registry for the first time, or updates the image by pulling the latest version. ### cleanup - Clean up old images and containers Docker images can take up quite a lot of disk space, and it's easy for them to build up if you switch between projects or your projects update their images. This sub-command will help to remove old images and containers. By default, `stack docker cleanup` will bring up an editor showing the images and containers on your system, with any stack images that haven't been used in the last seven days marked for removal. You can add or remove the `R` in the left-most column to flag or unflag an image/container for removal. When you save the file and quit the text editor, those images marked for removal will be deleted from your system. If you wish to abort the cleanup, delete all the lines from your editor. If you use Docker for purposes other than stack, you may have other images on your system as well. These will also appear in a separate section, but they will not be marked for removal by default. Run `stack docker cleanup --help` to see additional options to customize its behaviour. ### reset - Reset the Docker "sandbox" In order to preserve the contents of the in-container home directory between runs, a special "sandbox" directory is volume-mounted into the container. `stack docker reset` will reset that sandbox to its defaults. Note: `~/.stack` is separately volume-mounted, and is left alone during reset. Command-line options ------------------------------------------------------------------------------- The default Docker configuration can be overridden on the command-line. See `stack --docker-help` for a list of all Docker options, and consult [configuration](#configuration) section below for more information about their meanings. These are global options, and apply to all commands (not just `stack docker` sub-commands). Configuration ------------------------------------------------------------------------------- `stack.yaml` contains a `docker:` section with Docker settings. If this section is omitted, Docker containers will not be used. These settings can be included in project, user, or global configuration. Here is an annotated configuration file. The default values are shown unless otherwise noted. docker: # Set to false to disable using Docker. In the project configuration, # the presence of a `docker:` section implies docker is enabled unless # `enable: false` is set. In user and global configuration, this is not # the case. enable: true # The name of the repository to pull the image from. See the "repositories" # section of this document for more information about available repositories. # If this includes a tag (e.g. "my/image:tag"), that tagged image will be # used. Without a tag specified, the LTS version slug is added automatically. # Either `repo` or `image` may be specified, but not both. repo: "fpco/stack-build" # Exact Docker image name or ID. Overrides `repo`. Either `repo` or `image` # may be specified, but not both. (default none) image: "5c624ec1d63f" # Registry requires login. A login will be requested before attempting to # pull. registry-login: false # Username to log into the registry. (default none) registry-username: "myuser" # Password to log into the registry. (default none) registry-password: "SETME" # If true, the image will be pulled from the registry automatically, without # needing to run `stack docker pull`. See the "security" section of this # document for implications of enabling this. auto-pull: false # If true, the container will be run "detached" (in the background). Refer # to the Docker users guide for information about how to manage containers. # This option would rarely make sense in the configuration file, but can be # useful on the command-line. When true, implies `persist`. detach: false # If true, the container will not be deleted after it terminates. Refer to # the Docker users guide for information about how to manage containers. This # option would rarely make sense in the configuration file, but can be # useful on the command-line. `detach` implies `persist`. persist: false # What to name the Docker container. Only useful with `detach` or # `persist` true. (default none) container-name: "example-name" # Additional arguments to pass to `docker run`. (default none) run-args: ["--net=bridge"] # Directories from the host to volume-mount into the container. If it # contains a `:`, the part before the `:` is the directory on the host and # the part after the `:` is where it should be mounted in the container. # (default none, aside from the project and stack root directories which are # always mounted) mount: - "/foo/bar" - "/baz:/tmp/quux" # Environment variables to set in the container. Environment variables # are not automatically inherited from the host, so if you need any specific # variables, use the `--docker-env` command-line argument version of this to # pass them in. (default none) env: - "FOO=BAR" - "BAR=BAZ QUUX" # Location of database used to track image usage, which `stack docker cleanup` # uses to determine which images should be kept. On shared systems, it may # be useful to override this in the global configuration file so that # all users share a single database. database-path: "~/.stack/docker.db" # Location of a Docker container-compatible 'stack' executable with the # matching version. This executable must be built on linux-x86_64 and # statically linked. # Valid values are: # host: use the host's executable. This is the default when the host's # executable is known to work (e.g., from official linux-x86_64 bindist) # download: download a compatible executable matching the host's version. # This is the default when the host's executable is not known to work # image: use the 'stack' executable baked into the image. The version # must match the host's version # /path/to/stack: path on the host's local filesystem stack-exe: host # If true (the default when using the local Docker Engine), run processes # in the Docker container as the same UID/GID as the host. The ensures # that files written by the container are owned by you on the host. # When the Docker Engine is remote (accessed by tcp), defaults to false. set-user: true # Require the version of the Docker client to be within the specified # Cabal-style version range (e.g., ">= 1.6.0 && < 1.9.0") require-docker-version: "any" Image Repositories ------------------------------------------------------------------------------- FP Complete provides the following public image repositories on Docker Hub: - [fpco/stack-build](https://registry.hub.docker.com/u/fpco/stack-build/) (the default) - GHC (patched), tools (stack, cabal-install, happy, alex, etc.), and system developer libraries required to build all Stackage packages. FP Complete also builds custom variants of these images for their clients. These images can also be used directly with `docker run` and provide a complete Haskell build environment. In addition, most Docker images that contain the basics for running GHC can be used with Stack's Docker integration. For example, the [official Haskell image repository](https://hub.docker.com/_/haskell/) works. See [Custom images](#custom-images) for more details. Security ------------------------------------------------------------------------------- Having `docker` usable as a non-root user is always a security risk, and will allow root access to your system. It is also possible to craft a `stack.yaml` that will run arbitrary commands in an arbitrary docker container through that vector, thus a `stack.yaml` could cause stack to run arbitrary commands as root. While this is a risk, it is not really a greater risk than is posed by the docker permissions in the first place (for example, if you ever run an unknown shell script or executable, or ever compile an unknown Haskell package that uses Template Haskell, you are at equal risk). Nevertheless, there are [plans to close the stack.yaml loophole](https://github.com/commercialhaskell/stack/issues/260). One way to mitigate this risk is, instead of allowing `docker` to run as non-root, replace `docker` with a wrapper script that uses `sudo` to run the real Docker client as root. This way you will at least be prompted for your root password. As [@gregwebs](https://github.com/gregwebs) pointed out, put this script named `docker` in your PATH (and make sure you remove your user from the `docker` group as well, if you added it earlier): #!/bin/bash -e # The goal of this script is to maintain the security privileges of sudo # Without having to constantly type "sudo" exec sudo /usr/bin/docker "$@" Additional notes ------------------------------------------------------------------------------- ### Volume-mounts and ephemeral containers Since filesystem changes outside of the volume-mounted project directory are not persisted across runs, this means that if you `stack exec sudo apt-get install some-ubuntu-package`, that package will be installed but then the container it's installed in will disappear, thus causing it to have no effect. If you wish to make this kind of change permanent, see later instructions for how to create a [derivative Docker image](#derivative-image). Inside the container, your home directory is a special location that volume- mounted from within your project directory's `.stack-work` in such a way as that installed GHC/cabal packages are not shared between different Stackage snapshots. In addition, `~/.stack` is volume-mounted from the host. ### Network stack containers use the host's network stack within the container by default, meaning a process running in the container can connect to services running on the host, and a server process run within the container can be accessed from the host without needing to explicitly publish its port. To run the container with an isolated network, use `--docker-run-args` to pass the `--net` argument to `docker-run`. For example: stack --docker-run-args='--net=bridge --publish=3000:3000' \ exec some-server will run the container's network in "bridge" mode (which is Docker's default) and publish port 3000. ### Persistent container If you do want to do all your work, including editing, in the container, it might be better to use a persistent container in which you can install Ubuntu packages. You could get that by running something like `stack --docker-container-name=NAME --docker-persist exec --plain bash`. This means when the container exits, it won't be deleted. You can then restart it using `docker start -a -i NAME`. It's also possible to detach from a container while it continues running in the background using by pressing Ctrl-P Ctrl-Q, and then reattach to it using `docker attach NAME`. Note that each time you run `stack --docker-persist`, a _new_ persistent container is created (it will not automatically reuse the previous one). See the [Docker user guide](https://docs.docker.com/userguide/) for more information about managing Docker containers. ### Derivative image Creating your own custom derivative image can be useful if you need to install additional Ubuntu packages or make other changes to the operating system. Here is an example (replace `stack-build:custom` if you prefer a different name for your derived container, but it's best if the repo name matches what you're deriving from, only with a different tag, to avoid recompilation): ;;; On host $ sudo stack --docker-persist --docker-container-name=temp exec bash ;;; In container, make changes to OS # apt-get install r-cran-numderiv [...] # exit ;;; On host again $ docker commit temp stack-build:custom $ docker rm temp Now you have a new Docker image named `stack-build:custom`. To use the new image, run a command such as the following or update the corresponding values in your `stack.yaml`: stack --docker-image=stack-build:custom Note, however, that any time a new image is used, you will have to re-do this process. You could also use a Dockerfile to make this reusable. Consult the [Docker user guide](https://docs.docker.com/userguide/) for more on creating Docker images. ### Custom images The easiest way to create your own custom image us by extending FP Complete's images, but if you prefer to start from scratch, most images that include the basics for building code with GHC will work. The image doesn't even, strictly speaking, need to include GHC, but it does need to have libraries and tools that GHC requires (e.g., libgmp, gcc, etc.). There are also a few ways to set up images that tightens the integration: * Create a user and group named `stack`, and create a `~/.stack` directory for it. Any build plans and caches from it will be copied from the image by Stack, meaning they don't need to be downloaded separately. * Any packages in GHC's global package database will be available. This can be used to add private libraries to the image, or the make available a set of packages from an LTS release. Troubleshooting ------------------------------------------------------------------------------- ### "No Space Left on Device", but 'df' shows plenty of disk space This is likely due to the storage driver Docker is using, in combination with the large size and number of files in these images. Use `docker info|grep 'Storage Driver'` to determine the current storage driver. We recommend using either the `overlay` or `aufs` storage driver for stack, as they are least likely to give you trouble. On Ubuntu, `aufs` is the default for new installations, but older installations sometimes used `devicemapper`. The `devicemapper` storage driver's doesn't work well with large filesystems, and we have experienced other instabilities with it as well. We recommend against its use. The `btrfs` storage driver has problems running out of metadata space long before running out of actual disk space, which requires rebalancing or adding more metadata space. See [CoreOS's btrfs troubleshooting page](https://coreos.com/docs/cluster-management/debugging/btrfs-troubleshooting/) for details about how to do this. Pass the `-s ` argument to the Docker daemon to set the storage driver (in `/etc/default/docker` on Ubuntu). See [Docker daemon storage-driver option](https://docs.docker.com/reference/commandline/cli/#daemon-storage-driver-option) for more details. You may also be running out of inodes on your filesystem. Use `df -i` to check for this condition. Unfortunately, the number of inodes is set when creating the filesystem, so fixing this requires reformatting and passing the `-N` argument to mkfs.ext4. ### Name resolution doesn't work from within container On Ubuntu 12.04, by default `NetworkManager` runs `dnsmasq` service, which sets `127.0.0.1` as your DNS server. Since Docker containers cannot access this dnsmasq, Docker falls back to using Google DNS (8.8.8.8/8.8.4.4). This causes problems if you are forced to use internal DNS server. This can be fixed by executing: sudo sed 's@dns=dnsmasq@#dns=dnsmasq@' -i \ /etc/NetworkManager/NetworkManager.conf && \ sudo service network-manager restart If you have already installed Docker, you must restart the daemon for this change to take effect: sudo service docker restart The above commands turn off `dnsmasq` usage in NetworkManager configuration and restart network manager. They can be reversed by executing `sudo sed 's@#dns=dnsmasq@dns=dnsmasq@' -i /etc/NetworkManager/NetworkManager.conf && sudo service network-manager restart`. These instructions are adapted from [the Shipyard Project's QuickStart guide](https://github.com/shipyard/shipyard/wiki/QuickStart#127011-dns-server-problem-on-ubuntu). ### Cannot pull images from behind firewall that blocks TLS/SSL If you are behind a firewall that blocks TLS/SSL and pulling images from a private Docker registry, you must edit the system configuration so that the `--insecure-registry ` option is passed to the Docker daemon. For example, on Ubuntu: echo 'DOCKER_OPTS="--insecure-registry registry.example.com"' \ |sudo tee -a /etc/default/docker sudo service docker restart This does require the private registry to be available over plaintext HTTP. See [Docker daemon insecure registries documentation](https://docs.docker.com/reference/commandline/cli/#insecure-registries) for details. stack-1.9.3.1/doc/faq.md0000644000000000000000000006165313455666157013051 0ustar0000000000000000
# FAQ So that this doesn't become repetitive: for the reasons behind the answers below, see the [Architecture](architecture.md) page. The goal of the answers here is to be as helpful and concise as possible. ## What version of GHC is used when I run something like `stack ghci`? The version of GHC, as well as which packages can be installed, are specified by the _resolver_. This may be something like `lts-8.12`, which is from the [Long Term Support (LTS) Haskell](https://github.com/fpco/lts-haskell/) project. The [user guide](GUIDE.md) discusses resolvers in more detail. Which resolver is used is determined by finding the relevant `stack.yaml` configuration file for the directory you're running the command from. This essentially works by: 1. Check for a `STACK_YAML` environment variable or the `--stack-yaml` command line argument 2. If none present, check for a `stack.yaml` file in the current directory or any parents 3. If no `stack.yaml` was found, use the _implicit global_ The implicit global is a shared project used whenever you're outside of another project. It's a sort of "mutable shared state" that you should be aware of when working with Stack. The most recent request when working with the implicit global is how to move to a more recent LTS snapshot. You can do this by running the following from outside of a project: stack config set resolver lts ## Where is stack installed and will it interfere with `ghc` (etc) I already have installed? Stack itself is installed in normal system locations based on the mechanism you used (see the [Install and upgrade](install_and_upgrade.md) page). Stack installs the Stackage libraries in `~/.stack` and any project libraries or extra dependencies in a `.stack-work` directory within each project's directory. None of this should affect any existing Haskell tools at all. ## What is the relationship between stack and cabal? * Cabal-the-library is used by stack to build your Haskell code. * cabal-install (the executable) is used by stack for its dependency solver functionality. * A .cabal file is provided for each package, and defines all package-level metadata just like it does in the cabal-install world: modules, executables, test suites, etc. No change at all on this front. * A stack.yaml file references 1 or more packages, and provides information on where dependencies come from. * `stack build` currently initializes a stack.yaml from the existing .cabal file. Project initialization is something that is still being discussed and there may be more options here for new projects in the future (see issue [253](https://github.com/commercialhaskell/stack/issues/253)) ## I need to use a different version of a package than what is provided by the LTS Haskell snapshot I'm using, what should I do? You can make tweaks to a snapshot by modifying the `extra-deps` configuration value in your `stack.yaml` file, e.g.: ```yaml resolver: lts-2.9 packages: - '.' extra-deps: - text-1.2.1.1 ``` ## I need to use a package (or version of a package) that is not available on hackage, what should I do? Add it to the `packages` list in your project's `stack.yaml`, specifying the package's source code location relative to the directory where your `stack.yaml` file lives, e.g. ```yaml resolver: lts-2.10 packages: - '.' - third-party/proprietary-dep - github-version-of/conduit - patched/diagrams extra-deps: [] ``` The above example specifies that it should include the package at the root directory (`'.'`), that the `proprietary-dep` package is found in the project's `third-party` folder, that the `conduit` package is found in the project's `github-version-of` folder, and that the `diagrams` package is found in the project's `patched` folder. This autodetects changes and reinstalls the package. To install packages directly from a Git repository, use e.g.: ```yaml resolver: lts-2.10 packages: - location: git: https://github.com/githubuser/reponame.git commit: somecommitID ``` Note that the `- '.'` line has been omitted, so the package in the root directory will not be used. ## What is the meaning of the arguments given to stack build, test, etc? Those are the targets of the build, and can have one of three formats: * A package name (e.g., `my-package`) will mean that the `my-package` package must be built * A package identifier (e.g., `my-package-1.2.3`), which includes a specific version. This is useful for passing to `stack install` for getting a specific version from upstream * A directory (e.g., `./my-package`) for including a local directory's package, including any packages in subdirectories ## I need to modify an upstream package, how should I do it? Typically, you will want to get the source for the package and then add it to your `packages` list in stack.yaml. (See the previous question.) `stack unpack` is one approach for getting the source. Another would be to add the upstream package as a submodule to your project. ## Am I required to use a Stackage snapshot to use stack? No, not at all. If you prefer dependency solving to curation, you can continue with that workflow. Instead of describing the details of how that works here, it's probably easiest to just say: run `stack init --solver` and look at the generated stack.yaml. ## How do I use this with sandboxes? Explicit sandboxing on the part of the user is not required by stack. All builds are automatically isolated into separate package databases without any user interaction. This ensures that you won't accidentally corrupt your installed packages with actions taken in other projects. ## Can I run `cabal` commands inside `stack exec`? With a recent enough version of cabal-install (>= 1.22), you can. For older versions, due to [haskell/cabal#1800](https://github.com/haskell/cabal/issues/1800), this does not work. Note that even with recent versions, for some commands you may need this extra level of indirection: ``` $ stack exec -- cabal exec -- cabal ``` However, virtually all `cabal` commands have an equivalent in stack, so this should not be necessary. In particular, `cabal` users may be accustomed to the `cabal run` command. In stack: ``` $ stack build && stack exec ``` Or, if you want to install the binaries in a shared location: ``` $ stack install $ ``` assuming your `$PATH` has been set appropriately. ## Using custom preprocessors If you have a custom preprocessor, for example, Ruby, you may have a file like: ***B.erb*** ``` haskell module B where <% (1..5).each do |i| %> test<%= i %> :: Int test<%= i %> = <%= i %> <% end %> ``` To ensure that Stack picks up changes to this file for rebuilds, add the following line to your .cabal file: extra-source-files: B.erb ## I already have GHC installed, can I still use stack? Yes. In its default configuration, stack will simply ignore any system GHC installation and use a sandboxed GHC that it has installed itself (typically via the `stack setup` command). You can find these sandboxed GHC installations in `~/.stack/programs/$platform/ghc-$version/`. If you would like stack to use your system GHC installation, use the [`--system-ghc` flag](yaml_configuration.md#system-ghc) or run `stack config set system-ghc --global true` to make stack check your `PATH` for a suitable GHC by default. Note that stack can only use a system GHC installation if its version is compatible with the configuration of the current project, particularly the [`resolver` setting](yaml_configuration.md#resolver). Note that GHC installation doesn't work for all OSes, so in some cases you will need to use `system-ghc` and install GHC yourself. ## How does stack determine what GHC to use? In its default configuration, stack determines from the current project which GHC version, architecture etc. it needs. It then looks in `~/.stack/programs/$platform/ghc-$version/` for a compatible GHC, requesting to install one via `stack setup` if none is found. If you are using the [`--system-ghc` flag](yaml_configuration.md/#system-ghc) or have configured `system-ghc: true` either in the project `stack.yaml` or the global `~/.stack/config.yaml`, stack will use the first GHC that it finds on your `PATH`, falling back on its sandboxed installations only if the found GHC doesn't comply with the various requirements (version, architecture) that your project needs. See [this issue](https://github.com/commercialhaskell/stack/issues/420) for a detailed discussion of stack's behavior when `system-ghc` is enabled. ## How do I upgrade to GHC 7.10.2 with stack? If you already have a prior version of GHC use `stack --resolver ghc-7.10 setup --reinstall`. If you don't have any GHC installed, you can skip the `--reinstall`. ## How do I get extra build tools? stack will automatically install build tools required by your packages or their dependencies, in particular alex and happy. __NOTE__: This works when using lts or nightly resolvers, not with ghc or custom resolvers. You can manually install build tools by running, e.g., `stack build alex happy`. ## How does stack choose which snapshot to use when creating a new config file? It checks the two most recent LTS Haskell major versions and the most recent Stackage Nightly for a snapshot that is compatible with all of the version bounds in your .cabal file, favoring the most recent LTS. For more information, see the snapshot auto-detection section in the architecture document. ## I'd like to use my installed packages in a different directory. How do I tell stack where to find my packages? Set the `STACK_YAML` environment variable to point to the `stack.yaml` config file for your project. Then you can run `stack exec`, `stack ghc`, etc., from any directory and still use your packages. ## My tests are failing. What should I do? Like all other targets, `stack test` runs test suites in parallel by default. This can cause problems with test suites that depend on global resources such as a database or binding to a fixed port number. A quick hack is to force stack to run all test suites in sequence, using `stack test --jobs=1`. For test suites to run in parallel developers should ensure that their test suites do not depend on global resources (e.g. by asking the OS for a random port to bind to) and where unavoidable, add a lock in order to serialize access to shared resources. ## Can I get bash autocompletion? Yes, see the [shell-autocompletion documentation](shell_autocompletion.md) ## How do I update my package index? Users of cabal are used to running `cabal update` regularly. You can do the same with stack by running `stack update`. But generally, it's not necessary: if the package index is missing, or if a snapshot refers to package/version that isn't available, stack will automatically update and then try again. If you run into a situation where stack doesn't automatically do the update for you, please report it as a bug. ## Isn't it dangerous to automatically update the index? Can't that corrupt build plans? No, stack is very explicit about which packages it's going to build for you. There are three sources of information to tell it which packages to install: the selected snapshot, the `extra-deps` configuration value, and your local packages. The only way to get stack to change its build plan is to modify one of those three. Updating the index will have no impact on stack's behavior. ## I have a custom package index I'd like to use, how do I do so? You can configure this in your stack.yaml. See [YAML configuration](yaml_configuration.md). ## How can I make sure my project builds against multiple ghc versions? You can create multiple yaml files for your project, one for each build plan. For example, you might set up your project directory like so: ``` myproject/ stack-7.8.yaml stack-7.10.yaml stack.yaml --> symlink to stack-7.8.yaml myproject.cabal src/ ... ``` When you run `stack build`, you can set the `STACK_YAML` environment variable to indicate which build plan to use. ``` $ stack build # builds using the default stack.yaml $ STACK_YAML=stack-7.10.yaml stack build # builds using the given yaml file ``` ## I heard you can use this with Docker? Yes, stack supports using Docker with images that contain preinstalled Stackage packages and the tools. See [Docker integration](docker_integration.md) for details. ## How do I use this with Travis CI? See the [Travis CI instructions](travis_ci.md) ## What is licensing restrictions on Windows? Currently on Windows GHC produces binaries linked statically with [GNU Multiple Precision Arithmetic Library](https://gmplib.org/) (GMP), which is used by [integer-gmp](https://hackage.haskell.org/package/integer-gmp) library to provide big integer implementation for Haskell. Contrary to the majority of Haskell code licensed under permissive BSD3 license, GMP library is licensed under LGPL, which means resulting binaries [have to be provided with source code or object files](http://www.gnu.org/licenses/gpl-faq.html#LGPLStaticVsDynamic). That may or may not be acceptable for your situation. Current workaround is to use GHC built with alternative big integer implementation called integer-simple, which is free from LGPL limitations as it's pure Haskell and does not use GMP. Unfortunately it has yet to be available out of the box with stack. See [issue #399](https://github.com/commercialhaskell/stack/issues/399) for the ongoing effort and information on workarounds. ## How to get a working executable on Windows? When executing a binary after building with `stack build` (e.g. for target "foo"), the command `foo.exe` might complain about missing runtime libraries (whereas `stack exec foo` works). Windows is not able to find the necessary C++ libraries from the standard prompt because they're not in the PATH environment variable. `stack exec` works because it's modifying PATH to include extra things. Those libraries are shipped with GHC (and, theoretically in some cases, MSYS). The easiest way to find them is `stack exec which`. E.g. >stack exec which libstdc++-6.dll /c/Users/Michael/AppData/Local/Programs/stack/i386-windows/ghc-7.8.4/mingw/bin/libstdc++-6.dll A quick workaround is adding this path to the PATH environment variable or copying the files somewhere Windows finds them (cf. https://msdn.microsoft.com/de-de/library/7d83bc18.aspx). Cf. issue [#425](https://github.com/commercialhaskell/stack/issues/425). ## Can I change stack's default temporary directory? Stack downloads and extracts files to `$STACK_ROOT/programs` on most platforms, which defaults to `~/.stack/programs`. On Windows `$LOCALAPPDATA\Programs\stack` is used. If there is not enough free space in this directory, Stack may fail. For instance, `stack setup` with a GHC installation requires roughly 1GB free. If this is an issue, you can set `local-programs-path` in your `~/.stack/config.yaml` to a directory on a file system with more free space. If you use Stack with Nix integration, be aware that Nix uses a `TMPDIR` variable, and if it is not set Nix sets it to some subdirectory of `/run`, which on most Linuxes is a Ramdir. Nix will run the builds in `TMPDIR`, therefore if you don't have enough RAM you will get errors about disk space. If this happens to you, please _manually_ set `TMPDIR` before launching Stack to some directory on the disk. ## Why doesn't stack rebuild my project when I specify `--ghc-options` on the command line? Because GHC options often only affect optimization levels and warning behavior, stack doesn't recompile when it detects an option change by default. This behavior can be changed though by setting the [`rebuild-ghc-options` option](yaml_configuration.md#rebuild-ghc-options) to `true`. To force recompilation manually, use the `--force-dirty` flag. If this still doesn't lead to a rebuild, add the `-fforce-recomp` flag to your `--ghc-options`. ## Why doesn't stack apply my `--ghc-options` to my dependencies? By default, stack applies command line GHC options only to local packages (these are all the packages that are specified in the `packages` section of your `stack.yaml`). For an explanation of this choice see [this discussion on the issue tracker](https://github.com/commercialhaskell/stack/issues/827#issuecomment-133263678). If you still want to set specific GHC options for a dependency, use the [`ghc-options` option](yaml_configuration.md#ghc-options) in your `stack.yaml` or global `~/.stack/config.yaml`. To change the set of packages that command line GHC options apply to, use the [`apply-ghc-options` option](yaml_configuration.md#apply-ghc-options). ## stack setup on a windows system only tells me to add certain paths to the PATH variable instead of doing it If you are using a powershell session, it is easy to automate even that step: $env:Path = ( stack setup | %{ $_ -replace '[^ ]+ ', ''} ), $env:Path -join ";" ## How do I reset / remove Stack (such as to do a completely fresh build)? The first thing to remove is project-specific `.stack-work` directory within the project's directory. Next, remove `~/.stack` directory overall. You may have errors if you remove the latter but leave the former. Removing Stack itself will relate to how it was installed, and if you used GHC installed outside of Stack, that would need to be removed separately. ## How does stack handle parallel builds? What exactly does it run in parallel? See [issue #644](https://github.com/commercialhaskell/stack/issues/644) for more details. ## I get strange `ld` errors about recompiling with "-fPIC" (Updated in December 2017) This is related to more recent versions of Linux distributions that have GCC with PIE enabled by default. The continuously-updated distros like Arch, in particular, had been in flux with this change and the upgrading libtinfo6/ncurses6, and there were some workarounds attempted in Stack that ended up causing trouble as these distros evolved. GHC added official support for this setup in 8.0.2, so if you are using an older version your best bet is to upgrade. You may be able to work around it for older versions by editing `~/.stack/programs/x86_64-osx/ghc-VER/lib/ghc- VER/settings` (replace `VER` with the GHC version) and adding `-no-pie` (or `--no-pie` in the case of Gentoo, at least as of December 2017) to the __C compiler link flags__. If `stack setup` complains that there is no `linuxNN-*-nopie` bindist available, try adding `ghc-build: *` (replacing the `*` with the actual value that precedes `-nopie`, which may be empty) to your `~/.stack/config.yaml` (this will no longer be necessary for stack >= 1.7). If you are experiencing this with GHC >= 8.0.2, try running `stack setup --reinstall` if you've upgraded your Linux distribution or you set up GHC before late December 2017. If you are still having trouble after trying the above, check the following for more possible workarounds: * [Previous version of this FAQ entry](https://docs.haskellstack.org/en/v1.6.3/faq/#i-get-strange-ld-errors-about-recompiling-with-fpic) * Related issues: [#3518](https://github.com/commercialhaskell/stack/issues/3518), [#2712](https://github.com/commercialhaskell/stack/issues/2712), [#3630](https://github.com/commercialhaskell/stack/issues/3630), [#3648](https://github.com/commercialhaskell/stack/issues/3648) ## Where does the output from `--ghc-options=-ddump-splices` (and other `-ddump*` options) go? These are written to `*.dump-*` files inside the package's `.stack-work` directory. Specifically, they will be available at `PKG-DIR/$(stack path --dist-dir)/build/SOURCE-PATH`, where `SOURCE-PATH` is the path to the source file, relative to the location of the `*.cabal` file. When building named components such as test-suites, `SOURCE-PATH` will also include `COMPONENT/COMPONENT-tmp`, where `COMPONENT` is the name of the component. ## Why is DYLD_LIBRARY_PATH ignored? If you are on Mac OS X 10.11 ("El Capitan") or later, there is an [upstream GHC issue](https://ghc.haskell.org/trac/ghc/ticket/11617) which [prevents the `DYLD_LIBRARY_PATH` environment variable from being passed to GHC](https://github.com/commercialhaskell/stack/issues/1161) when System Integrity Protection (a.k.a. "rootless") is enabled. There are two known workarounds: 1. Known to work in all cases: [disable System Integrity Protection](http://osxdaily.com/2015/10/05/disable-rootless-system-integrity-protection-mac-os-x/). **WARNING: Disabling SIP will severely reduce the security of your system, so only do this if absolutely necessary!** 2. Experimental: [modify GHC's shell script wrappers to use a shell outside the protected directories](https://github.com/commercialhaskell/stack/issues/1161#issuecomment-186690904). ## Why do I get a `/usr/bin/ar: permission denied` error? If you are on OS X 10.11 ("El Capitan") or later, GHC 7.8.4 is [incompatible with System Integrity Protection (a.k.a. "rootless")](https://github.com/commercialhaskell/stack/issues/563). GHC 7.10.2 includes a fix, so this only affects users of GHC 7.8.4. If you cannot upgrade to GHC 7.10.2, you can work around it by [disabling System Integrity Protection](http://osxdaily.com/2015/10/05/disable-rootless-system-integrity-protection-mac-os-x/). **WARNING: Disabling SIP will severely reduce the security of your system, so only do this if absolutely necessary!** ## Why is the `--` argument separator ignored in Windows PowerShell Some versions of Windows PowerShell [don't pass the `--` to programs](https://github.com/commercialhaskell/stack/issues/813). The workaround is to quote the `"--"`, e.g.: stack exec "--" cabal --version This is known to be a problem on Windows 7, but seems to be fixed on Windows 10. ## Does stack also install the system/C libraries that some Cabal packages depend on? No, this is currently out of the scope of stack's target set of features. Instead of attempting to automate the installation of 3rd party dependencies, we have the following approaches for handling system dependencies: * Nix and docker help make your build and execution environment deterministic and predictable. This way, you can install system dependencies into a container, and share this container with all developers. * If you have installed some libraries into a non-standard location, [`extra-lib-dirs` / `extra-include-dirs`](yaml_configuration.md#extra-include-dirsextra-lib-dirs) to specify it. In the future, stack might give OS specific suggestions for how to install system libraries. ## How can I make `stack` aware of my custom SSL certificates? ### macOS In principle, you can use the following command to add a certificate to your system certificate keychain: sudo security add-trusted-cert -d -r trustRoot -k /Library/Keychains/System.keychain Some users have reported issues with this approach, see [#907](https://github.com/commercialhaskell/stack/issues/907) for more information. ### Other *NIX OSs Use the `SYSTEM_CERTIFICATE_PATH` environment variable to point at the directory where you keep your SSL certificates. ## How do I get `verbose` output from GHC when I build with cabal? Unfortunately `stack build` does not have an obvious equivalent to `cabal build -vN` which shows verbose output from GHC when building. The easiest workaround is to add `ghc-options: -vN` to the .cabal file or pass it via `stack build --ghc-options="-v"`. ## Does Stack support the Hpack specification? Yes: * If a package directory contains an Hpack `package.yaml` file, then Stack will use it to generate a `.cabal` file when building the package. * You can run `stack init` to initialize a `stack.yaml` file regardless of whether your packages are declared with `.cabal` files or with Hpack `package.yaml` files. * You can use the `with-hpack` configuration option to specify an Hpack executable to use instead of the Hpack bundled with Stack. ## How do I resolve linker errors when running `stack setup` or `stack build` on macOS? This is likely to be caused by having a LLVM installation and default Apple Clang compiler both under the `PATH`. The symptom of this issue is a linker error "bad relocation (Invalid pointer diff)". The compiler picks up inconsistent versions of binaries and the mysterious error occurs. The workaround is to remove LLVM binaries from the `PATH`. ## How do I suppress `'-nopie'` warnings with `stack build` on macOS? ``` clang: warning: argument unused during compilation: '-nopie' [-Wunused-command-line-argument] ``` This warning is shown when compiler support of `-no-pie` is expected but unavailable. It's possible to bypass the warning for a specific version of GHC by modifying a global setting: ``` # ~/.stack/programs/x86_64-osx/ghc-8.2.2/lib/ghc-8.2.2/settings -- ("C compiler supports -no-pie", "YES"), ++ ("C compiler supports -no-pie", "NO"), ``` **Note that we're fixing `ghc-8.2.2` in this case; repeat for other versions as necessary.** You should apply this fix for the version of GHC that matches your resolver. Issue [#4009](https://github.com/commercialhaskell/stack/issues/4009) on GitHub goes into further detail. stack-1.9.3.1/doc/ghci.md0000644000000000000000000001014613455666157013203 0ustar0000000000000000
# GHCi `stack ghci` allows you to load components and files of your project into `ghci`. It uses the same TARGET syntax as `stack build`, and can also take options like `--test`, `--bench`, and `--flag`. Similarly to `stack build`, the default is to load up ghci with all libraries and executables in the project. In order to load multiple components, `stack ghci` combines all of the ghc options together. This doesn't work in the general case, but when the packages being loaded share similar conventions, it should work out. A common source of issues is when one component defines default extensions which aren't assumed by another component. For example, specifying `NoImplicitPrelude` in one component but not another is quite likely to cause failures. `ghci` will be run with `-XNoImplicitPrelude`, but it is likely that modules in the other component assume that the Prelude is implicitly imported. ## Selecting Main module When loading multiple packages, there may be multiple definitions for the `Main` module. You can specify which Main module to load by passing in the `--main-is TARGET` flag. If no selection is made and there are multiple `Main` modules, you will be asked to select from a list of options. ## Speeding up initial load There are two ways to speed up the initial startup of ghci: * `--no-build`, to skip an initial build step. This only works if the dependencies have already been built. * `--no-load`, to skip loading all defined modules into ghci. You can then directly use `:load MyModule` to load a specific module in your project. ## Loading just the main module By default, `stack ghci` loads and imports all of the modules in the package. This allows you to easily use anything exported by your package. This is usually quite convenient, but in some cases it makes sense to only load one module, or no modules at all. The `--only-main` flag allows this. It specifies that only the main module will be loaded, if any. This is particularly useful in the following circumstances: 1. You're loading the project in order to run it in ghci (e.g. via `main`), and you intend to reload while developing. Without the `--only-main` flag, you will need to quit and restart ghci whenever a module gets deleted. With the flag, reloading should work fine in this case. 2. If many of your modules have exports named the same thing, then you'll need to refer to them using qualified names. To avoid this, it may be easier to use `--only-main` to start with a blank slate and just import the modules you are interested in. ## Loading a filepath directly Instead of the `TARGET` syntax, it is also possible to directly run `stack ghci src/MyFile.hs`. This will figure out which component the file is associated with, and use the options from that component. ## Specifying extra packages to build / depend on Sometimes you want to load ghci with an additional package, that isn't a direct dependency of your components. This can be achieved by using the `--package` flag. For example, if I want to experiment with the lens library, I can run `stack ghci --package lens`. ## Running plain ghci `stack ghci` always runs ghci configured to load code from packages in your project. In particular, this means it passes in flags like `-hide-all-packages` and `-package-id=` in order to configure which packages are visible to ghci. For doing experiments which just involve packages installed in your databases, it may be useful to run ghci plainly like `stack exec ghci`. This will run a plain `ghci` in an environment which includes `GHC_PACKAGE_PATH`, and so will have access to your databases. *Note*: Running `stack ghci` on a pristine copy of the code doesn't currently build libraries ([#2790](https://github.com/commercialhaskell/stack/issues/2790)) or internal libraries ([#4148](https://github.com/commercialhaskell/stack/issues/4148)). It is recommended to always run a `stack build` before running `stack ghci`, until these two issues are closed. stack-1.9.3.1/doc/ghcjs.md0000644000000000000000000001766013455666157013377 0ustar0000000000000000
# GHCJS (experimental) To use GHCJS with stack, place a GHCJS version in the [`compiler`](yaml_configuration.md#compiler) field of `stack.yaml`. After this, some stack commands should work with GHCJS. In particular: * `stack setup` will install GHCJS from source and boot it, which takes a long time. * `stack build` will compile your code to JavaScript. In particular, the generated code for an executable ends up in `$(stack path --local-install-root)/bin/EXECUTABLE.jsexe/all.js` (bash syntax, where `EXECUTABLE` is the name of your executable). You can also build existing stack projects which target GHC, and instead build them with GHCJS. For example: `stack build --compiler ghcjs-0.2.0.9006020_ghc-7.10.3` There are advanced options for `stack setup`: `--ghcjs-boot-options` (one word at a time) and `--[no-]ghcjs-boot-clean` which will pass your settings down to the `ghcjs-boot`. You will need to know exactly what you are doing with them. Sidenote: If you receive a message like `The program 'ghcjs' version >=0.1 is required but the version of .../ghcjs could not be determined.`, then you may need to install a different version of `node`. See [issue #1496](https://github.com/commercialhaskell/stack/issues/1496). ## Example Configurations ### GHCJS repacked for snapsnots lts-8 and lts-9 Please see the [ghcjs-stack-dist repository](https://github.com/matchwood/ghcjs-stack-dist) for `lts-8` and `lts-9` configurations and refer to the [README](https://github.com/matchwood/ghcjs-stack-dist/blob/master/README.md) for common issues. Support for `> lts-9` snapshots (`GHC 8.2` and above) is currently [work in progress](https://github.com/matchwood/ghcjs-stack-dist/issues/10). ### GHCJS repacked for snapsnots < lts-8 These versions of GHCJS were created by [Marcin Tolysz](https://github.com/tolysz), and were particularly crafted to include package versions which match those expected by particular stackage snapshots. For `ghcjs` based on `ghc-7.10.3` one could try: ```yaml resolver: lts-6.30 compiler: ghcjs-0.2.0.9006030_ghc-7.10.3 compiler-check: match-exact setup-info: ghcjs: source: ghcjs-0.2.0.9006030_ghc-7.10.3: url: http://ghcjs.tolysz.org/lts-6.30-9006030.tar.gz sha1: 2371e2ffe9e8781808b7a04313e6a0065b64ee51 ``` Or for the latest one based on `ghc-8.0.1` (with more features): ```yaml resolver: lts-7.19 compiler: ghcjs-0.2.1.9007019_ghc-8.0.1 compiler-check: match-exact setup-info: ghcjs: source: ghcjs-0.2.1.9007019_ghc-8.0.1: url: http://ghcjs.tolysz.org/ghc-8.0-2017-02-05-lts-7.19-9007019.tar.gz sha1: d2cfc25f9cda32a25a87d9af68891b2186ee52f9 ``` The latter can be generated via: https://github.com/tolysz/prepare-ghcjs the former is a bit more manual. Those bundles are only tested against the latest `node-7.4.0`. In order to correctly boot and use ghcjs, one might need to install `alex` `happy` `hscolour` `hsc2hs` with the normal ghc. Older resolvers: |resolver|ghcjs|url|sha1| |---|---|---|---| | lts-7.19 |0.2.1| http://ghcjs.tolysz.org/ghc-8.0-2017-02-05-lts-7.19-9007019.tar.gz | d2cfc25f9cda32a25a87d9af68891b2186ee52f9 | | lts-7.15 |0.2.1| http://ghcjs.tolysz.org/ghc-8.0-2017-01-11-lts-7.15-9007015.tar.gz | 30d34e9d704bdb799066387dfa1ba98b8884d932 | | lts-7.14 |0.2.1| http://ghcjs.tolysz.org/ghc-8.0-2016-12-25-lts-7.14-9007014.tar.gz | 530c4ee5e19e2874e128431c7ad421e336df0303 | | lts-7.13 |0.2.1| http://ghcjs.tolysz.org/ghc-8.0-2016-12-18-lts-7.13-9007013.tar.gz | 0d2ebe0931b29adca7cb9d9b9f77d60095bfb864 | | lts-7.8 || http://ghcjs.tolysz.org/ghc-8.0-2016-11-07-lts-7.8-9007008.tar.gz | 190300a3725cde44b2a08be9ef829f2077bf8825 | | lts-7.7 || http://ghcjs.tolysz.org/ghc-8.0-2016-11-03-lts-7.7-9007007.tar.gz | ce169f85f1c49ad613ae77fc494d5565452ff59a | | lts-7.5 || http://ghcjs.tolysz.org/ghc-8.0-2016-10-24-lts-7.5-9007005.tar.gz | 450e81028d7f1eb82a16bc4b0809f30730c3e173 | | lts-7.4 || http://ghcjs.tolysz.org/ghc-8.0-2016-10-22-lts-7.4-9007004.tar.gz | ed77b3c15fedbadad5ab0e0afe1bd42c0a8695b4 | | lts-7.3 || http://ghcjs.tolysz.org/ghc-8.0-2016-10-11-lts-7.3-9007003.tar.gz | 3196fd5eaed670416083cf3678396d02c50096de | | lts-7.2 || http://ghcjs.tolysz.org/ghc-8.0-2016-10-01-lts-7.2-9007002.tar.gz | a41ae415328e2b257d40724d13d1386390c26322 | | lts-7.1 || http://ghcjs.tolysz.org/ghc-8.0-2016-09-26-lts-7.1-9007001-mem.tar.gz | e640724883238593e2d2f7f03991cb413ec0347b | | lts-6.25 | 0.2.0 | http://ghcjs.tolysz.org/lts-6.25-9006025.tar.gz | 3c87228579b55c05e227a7876682c2a7d4c9c007 | | lts-6.21 || http://ghcjs.tolysz.org/lts-6.21-9006021.tar.gz | 80b83f85dcec182093418e843979f4cee092fa85 | | lts-6.20 || http://ghcjs.tolysz.org/lts-6.20-9006020.tar.gz | a6cea90cd8121eee3afb201183c6e9bd6bacd94a | | lts-6.19 || http://ghcjs.tolysz.org/lts-6.19-9006019.tar.gz | ef4264d5a93b269ee4ec8f9d5139da030331d65a | | lts-6.18 || http://ghcjs.tolysz.org/lts-6.18-9006018.tar.gz | 3e9f345116c851349a5a551ffd94f7e0b74bfabb | If you do not use the same resolver, say, an older LTS snapshot, you will get some warnings like this: ``` Ignoring that the GHCJS boot package "aeson" has a different version, 0.9.0.1, than the resolver's wanted version, 0.8.0.2 Ignoring that the GHCJS boot package "attoparsec" has a different version, 0.13.0.1, than the resolver's wanted version, 0.12.1.6 Ignoring that the GHCJS boot package "scientific" has a different version, 0.3.3.8, than the resolver's wanted version, 0.3.4.2 ... ``` These warnings can usually be safely ignored, but they do indicate a divergence between your snapshot's packages, and those that are being used to compile your project. You will normally get these warnings when using a GHCJS tarball that has not been packaged with a particular snapshot in mind. ### GHCJS (old base) If you want to build some older GHCJS packages, you may need to use the "old base" GHCJS. To do this, use the following compiler info: ```yaml compiler: ghcjs-0.1.0.20150924_ghc-7.10.2 compiler-check: match-exact ``` ### Custom installed GHCJS In order to use a GHCJS installed on your PATH, just add the following to your `stack.yaml`: ```yaml compiler: ghcjs-0.2.0_ghc-7.10.2 ``` (Or, `ghcjs-0.1.0_ghc-7.10.2` if you are working with an older version) This is particularly useful when you have built GHCJS from source. ## Project with both client and server For projects with both a server and client, the recommended project organization is to put one or both of your `stack.yaml` files in sub-directories. This way, you can use the current working directory to specify whether you're working on the client or server. This will also allow more straightforward editor tooling, once projects like `ghc-mod` and `haskell-ide-engine` support GHCJS. For example, here's what a script for building both client and server looks like: ```bash #!/bin/bash # Build the client stack build --stack-yaml=client/stack.yaml # Copy over the javascript rm -f server/static/all.js cp $(stack path --stack-yaml=client/stack.yaml --local-install-root)/bin/client.jsexe/all.js server/static/all.js # Build the server stack build --stack-yaml=server/stack.yaml ``` You can also put both the yaml files in the same directory, and have e.g. `ghcjs-stack.yaml`, but this won't work well with editor integrations. ## Using stack without a snapshot If you don't want to use a snapshot, instead place the ghcjs version in the `resolver` field of your `stack.yaml`. This is also necessary when using stack `< 0.1.8`. ## Setting up GHCJS on Windows If `stack setup` command fails to successfully complete with message: `commitBuffer: invalid argument (invalid character)`, it means you have a locale problem. This problem is not exclusive to GHCJS, and might happen also during other builds. A workaround is to set _Language for non-Unicode programs_ to _English (US)_. For details see [stack issue #1448](https://github.com/commercialhaskell/stack/issues/1448). stack-1.9.3.1/doc/GUIDE.md0000644000000000000000000022707713455666157013143 0ustar0000000000000000
# User guide stack is a modern, cross-platform build tool for Haskell code. This guide takes a new stack user through the typical workflows. This guide will not teach Haskell or involve much code, and it requires no prior experience with the Haskell packaging system or other build tools. ## Stack's functions stack handles the management of your toolchain (including GHC — the Glasgow Haskell Compiler — and, for Windows users, MSYS), building and registering libraries, building build tool dependencies, and more. While it can use existing tools on your system, stack has the capacity to be your one-stop shop for all Haskell tooling you need. This guide will follow that stack-centric approach. ### What makes stack special? The primary stack design point is __reproducible builds__. If you run `stack build` today, you should get the same result running `stack build` tomorrow. There are some cases that can break that rule (changes in your operating system configuration, for example), but, overall, stack follows this design philosophy closely. To make this a simple process, stack uses curated package sets called __snapshots__. stack has also been designed from the ground up to be user friendly, with an intuitive, discoverable command line interface. For many users, simply downloading stack and reading `stack --help` will be enough to get up and running. This guide provides a more gradual tour for users who prefer that learning style. To build your project, stack uses a `stack.yaml` file in the root directory of your project as a sort of blueprint. That file contains a reference, called a __resolver__, to the snapshot which your package will be built against. Finally, stack is __isolated__: it will not make changes outside of specific stack directories. stack-built files generally go in either the stack root directory (default `~/.stack`) or `./.stack-work` directories local to each project. The stack root directory holds packages belonging to snapshots and any stack-installed versions of GHC. Stack will not tamper with any system version of GHC or interfere with packages installed by `cabal` or any other build tools. _NOTE_ In this guide, we'll use commands as run on a GNU/Linux system (specifically Ubuntu 14.04, 64-bit) and share output from that. Output on other systems — or with different versions of stack — will be slightly different, but all commands work cross-platform, unless explicitly stated otherwise. ## Downloading and Installation The [documentation dedicated to downloading stack](install_and_upgrade.md) has the most up-to-date information for a variety of operating systems, including multiple GNU/Linux flavors. Instead of repeating that content here, please go check out that page and come back here when you can successfully run `stack --version`. The rest of this session will demonstrate the installation procedure on a vanilla Ubuntu 14.04 machine. ``` michael@d30748af6d3d:~$ sudo apt-get install wget # installing ... michael@d30748af6d3d:~$ wget -qO- https://get.haskellstack.org/ | sh # downloading ... michael@d30748af6d3d:~$ stack --help # help output ... ``` With stack now up and running, you're good to go. Though not required, we recommend setting your PATH environment variable to include `$HOME/.local/bin`: ``` michael@d30748af6d3d:~$ echo 'export PATH=$HOME/.local/bin:$PATH' >> ~/.bashrc ``` ## Hello World Example With stack installed, let's create a new project from a template and walk through the most common stack commands. ### stack new We'll start off with the `stack new` command to create a new *project*, that will contain a Haskell *package* of the same name. So let's pick a valid package name first: > A package is identified by a globally-unique package name, which consists > of one or more alphanumeric words separated by hyphens. To avoid ambiguity, > each of these words should contain at least one letter. (From the [Cabal users guide](https://www.haskell.org/cabal/users-guide/developing-packages.html#developing-packages)) We'll call our project `helloworld`, and we'll use the `new-template` project template: ``` michael@d30748af6d3d:~$ stack new helloworld new-template ``` For this first stack command, there's quite a bit of initial setup it needs to do (such as downloading the list of packages available upstream), so you'll see a lot of output. Over the course of this guide a lot of the content will begin to make more sense. We now have a project in the `helloworld` directory! ### stack build Next, we'll run the most important stack command: `stack build`. ``` michael@d30748af6d3d:~$ cd helloworld michael@d30748af6d3d:~/helloworld$ stack build # installing ... building ... ``` stack needs a GHC in order to build your project. stack will discover that you are missing it and will install it for you. You can do this manually by using the `stack setup` command. You'll get intermediate download percentage statistics while the download is occurring. This command may take some time, depending on download speeds. __NOTE__: GHC will be installed to your global stack root directory, so calling `ghc` on the command line won't work. See the `stack exec`, `stack ghc`, and `stack runghc` commands below for more information. Once a GHC is installed, stack will then build your project. ### stack exec Looking closely at the output of the previous command, you can see that it built both a library called "helloworld" and an executable called "helloworld-exe". We'll explain more in the next section, but, for now, just notice that the executables are installed in our project's `./.stack-work` directory. Now, Let's use `stack exec` to run our executable (which just outputs the string "someFunc"): ``` michael@d30748af6d3d:~/helloworld$ stack exec helloworld-exe someFunc ``` `stack exec` works by providing the same reproducible environment that was used to build your project to the command that you are running. Thus, it knew where to find `helloworld-exe` even though it is hidden in the `./.stack-work` directory. ### stack test Finally, like all good software, helloworld actually has a test suite. Let's run it with `stack test`: ``` michael@d30748af6d3d:~/helloworld$ stack test # build output ... ``` Reading the output, you'll see that stack first builds the test suite and then automatically runs it for us. For both the `build` and `test` command, already built components are not built again. You can see this by running `stack build` and `stack test` a second time: ``` michael@d30748af6d3d:~/helloworld$ stack build michael@d30748af6d3d:~/helloworld$ stack test # build output ... ``` ## Inner Workings of stack In this subsection, we'll dissect the helloworld example in more detail. ### Files in helloworld Before studying stack more, let's understand our project a bit better. ``` michael@d30748af6d3d:~/helloworld$ find * -type f LICENSE README.md Setup.hs app/Main.hs helloworld.cabal package.yaml src/Lib.hs stack.yaml test/Spec.hs ``` The `app/Main.hs`, `src/Lib.hs`, and `test/Spec.hs` files are all Haskell source files that compose the actual functionality of our project (we won't dwell on them here). The `LICENSE` file and `README.md` have no impact on the build. The `helloworld.cabal` file is updated automatically as part of the `stack build` process and should not be modified. The files of interest here are `Setup.hs`, `stack.yaml`, and `package.yaml`. The `Setup.hs` file is a component of the Cabal build system which stack uses. It's technically not needed by stack, but it is still considered good practice in the Haskell world to include it. The file we're using is straight boilerplate: ```haskell import Distribution.Simple main = defaultMain ``` Next, let's look at our `stack.yaml` file, which gives our project-level settings. If you're familiar with YAML, you may recognize that the `flags` and `extra-deps` keys have empty values. We'll see more interesting usages for these fields later. Let's focus on the other two fields. `packages` tells stack which local packages to build. In our simple example, we have only a single package in our project, located in the same directory, so `'.'` suffices. However, stack has powerful support for multi-package projects, which we'll elaborate on as this guide progresses. The final field is `resolver`. This tells stack *how* to build your package: which GHC version to use, versions of package dependencies, and so on. Our value here says to use [LTS Haskell version 3.2](https://www.stackage.org/lts-3.2), which implies GHC 7.10.2 (which is why `stack setup` installs that version of GHC). There are a number of values you can use for `resolver`, which we'll cover later. Another file important to the build is `package.yaml`. Since Stack 1.6.1, the `package.yaml` is the preferred package format that is provided built-in by stack through [the hpack tool](https://github.com/sol/hpack). The default behaviour is to generate the `.cabal` file from this `package.yaml`, and accordingly you should **not** modify the `.cabal` file. It is also important to remember that stack is built on top of the Cabal build system. Therefore, an understanding of the moving parts in Cabal are necessary. In Cabal, we have individual *packages*, each of which contains a single `.cabal` file. The `.cabal` file can define 1 or more *components*: a library, executables, test suites, and benchmarks. It also specifies additional information such as library dependencies, default language pragmas, and so on. In this guide, we'll discuss the bare minimum necessary to understand how to modify a `package.yaml` file. You can see a full list of the available options at the [hpack documentation](https://github.com/sol/hpack#quick-reference). Haskell.org has the definitive [reference for the `.cabal` file format](https://www.haskell.org/cabal/users-guide/developing-packages.html). ### The setup command As we saw above, the `build` command installed GHC for us. Just for kicks, let's manually run the `setup` command: ``` michael@d30748af6d3d:~/helloworld$ stack setup stack will use a sandboxed GHC it installed For more information on paths, see 'stack path' and 'stack exec env' To use this GHC and packages outside of a project, consider using: stack ghc, stack ghci, stack runghc, or stack exec ``` Thankfully, the command is smart enough to know not to perform an installation twice. As the command output above indicates, you can use `stack path` for quite a bit of path information (which we'll play with more later). For now, we'll just look at where GHC is installed: ``` michael@d30748af6d3d:~/helloworld$ stack exec -- which ghc /home/michael/.stack/programs/x86_64-linux/ghc-7.10.2/bin/ghc ``` As you can see from that path (and as emphasized earlier), the installation is placed to not interfere with any other GHC installation, whether system-wide or even different GHC versions installed by stack. ### The build command The build command is the heart and soul of stack. It is the engine that powers building your code, testing it, getting dependencies, and more. Quite a bit of the remainder of this guide will cover more advanced `build` functions and features, such as building test and Haddocks at the same time, or constantly rebuilding blocking on file changes. *On a philosophical note:* Running the build command twice with the same options and arguments should generally be a no-op (besides things like rerunning test suites), and should, in general, produce a reproducible result between different runs. ## Adding dependencies Let's say we decide to modify our `helloworld` source a bit to use a new library, perhaps the ubiquitous text package. In `src/Lib.hs`, we can, for example add: ```haskell {-# LANGUAGE OverloadedStrings #-} module Lib ( someFunc ) where import qualified Data.Text.IO as T someFunc :: IO () someFunc = T.putStrLn "someFunc" ``` When we try to build this, things don't go as expected: ```haskell michael@d30748af6d3d:~/helloworld$ stack build # build failure output (abridged for clarity) ... /helloworld/src/Lib.hs:5:1: error: Could not find module `Data.Text.IO' Use -v to see a list of the files searched for. | 5 | import qualified Data.Text.IO as T | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ``` This means that the package containing the module in question is not available. To tell stack to use [text](https://hackage.haskell.org/package/text), you need to add it to your `package.yaml` file — specifically in your `dependencies` section, like this: ``` dependencies: - base >= 4.7 && < 5 - text # added here ``` Now if we rerun `stack build`, we should get a successful result: ``` michael@d30748af6d3d:~/helloworld$ stack build # build output ... ``` This output means that the text package was downloaded, configured, built, and locally installed. Once that was done, we moved on to building our local package (helloworld). At no point did we need to ask stack to build dependencies — it does so automatically. ### Listing Dependencies Let's have stack add a few more dependencies to our project. First, we'll include two new packages in the `dependencies` section for our library in our `package.yaml`: ``` dependencies: - filepath - containers ``` After adding these two dependencies, we can again run `stack build` to have them installed: ``` michael@d30748af6d3d:~/helloworld$ stack build # build output ... ``` Finally, to find out which versions of these libraries stack installed, we can ask stack to `ls dependencies`: ``` michael@d30748af6d3d:~/helloworld$ stack ls dependencies # dependency output ... ``` ### extra-deps Let's try a more off-the-beaten-track package: the joke [acme-missiles](http://www.stackage.org/package/acme-missiles) package. Our source code is simple: ```haskell module Lib ( someFunc ) where import Acme.Missiles someFunc :: IO () someFunc = launchMissiles ``` Again, we add this new dependency to the `package.yaml` file like this: ``` dependencies: - base >= 4.7 && 5 - text - filepath - containers - acme-missiles # added ``` However, rerunning `stack build` shows us the following error message: ``` michael@d30748af6d3d:~/helloworld$ stack build # build failure output ... ``` It says that it was unable to construct the build plan. This brings us to the next major topic in using stack. ## Curated package sets Remember above when `stack new` selected some [LTS resolver](https://github.com/fpco/lts-haskell#readme) for us? That defined our build plan and available packages. When we tried using the `text` package, it just worked, because it was part of the LTS *package set*. But `acme-missiles` is not part of that package set, so building failed. To add this new dependency, we'll use the `extra-deps` field in `stack.yaml` to define extra dependencies not present in the resolver. You can add this like so: ```yaml extra-deps: - acme-missiles-0.3 # not in the LTS ``` Now `stack build` will succeed. With that out of the way, let's dig a little bit more into these package sets, also known as *snapshots*. We mentioned the LTS resolvers, and you can get quite a bit of information about it at [https://www.stackage.org/lts](https://www.stackage.org/lts), including: * The appropriate resolver value (`resolver: lts-11.22`, as is currently the latest LTS) * The GHC version used * A full list of all packages available in this snapshot * The ability to perform a Hoogle search on the packages in this snapshot * A [list of all modules](https://www.stackage.org/lts/docs) in a snapshot, which can be useful when trying to determine which package to add to your `package.yaml` file. You can also see a [list of all available snapshots](https://www.stackage.org/snapshots). You'll notice two flavors: LTS (for "Long Term Support") and Nightly. You can read more about them on the [LTS Haskell Github page](https://github.com/fpco/lts-haskell#readme). If you're not sure which to use, start with LTS Haskell (which stack will lean towards by default as well). ## Resolvers and changing your compiler version Let's explore package sets a bit further. Instead of lts-11.22, let's change our `stack.yaml` file to use [the latest nightly](https://www.stackage.org/nightly). Right now, this is currently 2018-07-25 - please see the resolve from the link above to get the latest. Then, Rerunning `stack build` will produce: ``` michael@d30748af6d3d:~/helloworld$ stack build Downloaded nightly-2018-07-31 build plan. # build output ... ``` We can also change resolvers on the command line, which can be useful in a Continuous Integration (CI) setting, like on Travis. For example: ``` michael@d30748af6d3d:~/helloworld$ stack --resolver lts-11.22 build Downloaded lts-11.22 build plan. # build output ... ``` When passed on the command line, you also get some additional "short-cut" versions of resolvers: `--resolver nightly` will use the newest Nightly resolver available, `--resolver lts` will use the newest LTS, and `--resolver lts-2` will use the newest LTS in the 2.X series. The reason these are only available on the command line and not in your `stack.yaml` file is that using them: 1. Will slow down your build (since stack then needs to download information on the latest available LTS each time it builds) 2. Produces unreliable results (since a build run today may proceed differently tomorrow because of changes outside of your control) ### Changing GHC versions Finally, let's try using an older LTS snapshot. We'll use the newest 2.X snapshot: ``` michael@d30748af6d3d:~/helloworld$ stack --resolver lts-2 build # build output ... ``` This succeeds, automatically installing the necessary GHC along the way. So, we see that different LTS versions use different GHC versions and stack can handle that. ### Other resolver values We've mentioned `nightly-YYYY-MM-DD` and `lts-X.Y` values for the resolver. There are actually other options available, and the list will grow over time. At the time of writing: * `ghc-X.Y.Z`, for requiring a specific GHC version but no additional packages * Experimental GHCJS support * Experimental custom snapshot support The most up-to-date information can always be found in the [stack.yaml documentation](yaml_configuration.md#resolver). ## Existing projects Alright, enough playing around with simple projects. Let's take an open source package and try to build it. We'll be ambitious and use [yackage](https://www.stackage.org/package/yackage), a local package server using [Yesod](http://www.yesodweb.com/). To get the code, we'll use the `stack unpack` command: ``` cueball:~$ stack unpack yackage-0.8.0 Unpacked yackage-0.8.0 to /var/home/harendra/yackage-0.8.0/ cueball:~$ cd yackage-0.8.0/ ``` Note that you can also unpack to the directory of your liking instead of the current one by issueing: ``` cueball:~$ stack unpack yackage-0.8.0 --to ~/work ``` This will create a `yackage-0.8.0` directory inside `~/work` ### stack init This new directory does not have a `stack.yaml` file, so we need to make one first. We could do it by hand, but let's be lazy instead with the `stack init` command: ``` cueball:~/yackage-0.8.0$ stack init # init output ... ``` stack init does quite a few things for you behind the scenes: * Finds all of the `.cabal` files in your current directory and subdirectories (unless you use `--ignore-subdirs`) and determines the packages and versions they require * Finds the best combination of snapshot and package flags that allows everything to compile with minimum external dependencies * It tries to look for the best matching snapshot from latest LTS, latest nightly, other LTS versions in that order Assuming it finds a match, it will write your `stack.yaml` file, and everything will work. #### External Dependencies Given that LTS Haskell and Stackage Nightly have ~1400 of the most common Haskell packages, this will often be enough to build most packages. However, at times, you may find that not all dependencies required may be available in the Stackage snapshots. Let's simulate an unsatisfied dependency by adding acme-missiles to the `.cabal` file (yackage does not currently support hpack, but you can also [hpack-convert](https://github.com/yamadapc/hpack-convert) should you need to generate a `package.yaml`) build-depends and then re-initing: ``` cueball:~/yackage-0.8.0$ stack init --force # init failure output ``` stack has tested six different snapshots, and in every case discovered that acme-missiles is not available. In the end it suggested that you use the `--solver` command line switch if you want to use packages outside Stackage. So let's give it a try: ``` cueball:~/yackage-0.8.0$ stack init --force --solver # solver output ... ``` stack will complain that it needs a `cabal-install` installation. Let's get that: ``` cueball:~/yackage-0.8.0$ stack install cabal-install ``` Then run the above `stack init` command above again and it will succeed. As you can verify by viewing `stack.yaml`, three external dependencies were added by stack init under the `extra-deps` field. Of course, you could have added the external dependencies by manually editing `stack.yaml` but stack init does the hard work for you. #### Excluded Packages Sometimes multiple packages in your project may have conflicting requirements. In that case `stack init` will fail, so what do you do? You could manually create `stack.yaml` by omitting some packages to resolve the conflict. Alternatively you can ask `stack init` to do that for you by specifying `--omit-packages` flag on the command line. Let's see how that works. To simulate a conflict we will use acme-missiles-0.3 in yackage and we will also copy `yackage.cabal` to another directory and change the name of the file and package to yackage-test. In this new package we will use acme-missiles-0.2 instead. Let's see what happens when we run solver: ``` cueball:~/yackage-0.8.0$ stack init --force --solver --omit-packages # init failure output ... ``` Looking at `stack.yaml`, you will see that the excluded packages have been commented out under the `packages` field. In case wrong packages are excluded you can uncomment the right one and comment the other one. Packages may get excluded due to conflicting requirements among user packages or due to conflicting requirements between a user package and the resolver compiler. If all of the packages have a conflict with the compiler then all of them may get commented out. When packages are commented out you will see a warning every time you run a command which needs the configuration file. The warning can be disabled by editing the configuration file and removing it. #### Using a specific resolver Sometimes you may want to use a specific resolver for your project instead of `stack init` picking one for you. You can do that by using `stack init --resolver `. You can also init with a compiler resolver if you do not want to use a snapshot. That will result in all of your project's dependencies being put under the `extra-deps` section. #### Installing the compiler stack will automatically install the compiler when you run `stack build` but you can manually specify the compiler by running `stack setup `. #### Miscellaneous and diagnostics _Add selected packages_: If you want to use only selected packages from your project directory you can do so by explicitly specifying the package directories on the command line. _Duplicate package names_: If multiple packages under the directory tree have same name, stack init will report those and automatically ignore one of them. _Ignore subdirectories_: By default stack init searches all the subdirectories for `.cabal` files. If you do not want that then you can use `--ignore-subdirs` command line switch. _Cabal warnings_: stack init will show warnings if there were issues in reading a cabal package file. You may want to pay attention to the warnings as sometimes they may result in incomprehensible errors later on during dependency solving. _Package naming_: If the `Name` field defined in a cabal file does not match with the cabal file name then `stack init` will refuse to continue. _Cabal install errors_: stack init uses `cabal-install` to determine external dependencies. When cabal-install encounters errors, cabal errors are displayed as is by stack init for diagnostics. _User warnings_: When packages are excluded or external dependencies added stack will show warnings every time configuration file is loaded. You can suppress the warnings by editing the config file and removing the warnings from it. You may see something like this: ``` cueball:~/yackage-0.8.0$ stack build Warning: Some packages were found to be incompatible with the resolver and have been left commented out in the packages section. Warning: Specified resolver could not satisfy all dependencies. Some external packages have been added as dependencies. You can suppress this message by removing it from stack.yaml ``` ### stack solver While `stack init` is used to create stack configuration file from existing cabal files, `stack solver` can be used to fine tune or fix an existing stack configuration file. `stack solver` uses the existing file as a constraint. For example it will use only those packages specified in the existing config file or use existing external dependencies as constraints to figure out other dependencies. Let's try `stack solver` to verify the config that we generated earlier with `stack init`: ``` cueball:~/yackage-0.8.0$ stack solver # solver output ... ``` It says there are no changes needed to your configuration. Notice that it also reports `example/yackage-test.cabal` as missing from the config. It was purposely omitted by `stack init` to resolve a conflict. Sometimes `stack init` may not be able to give you a perfect configuration. In that case, you can tweak the configuration file as per your requirements and then run `stack solver`, it will check the file and suggest or apply any fixes needed. For example, if `stack init` ignored certain packages due to name conflicts or dependency conflicts, the choice that `stack init` made may not be the correct one. In that case you can revert the choice and use solver to fix things. Let's try commenting out `.` and uncommenting `examples/` in our previously generated `stack.yaml` and then run `stack solver`: ``` cueball:~/yackage-0.8.0$ stack solver # solver failure output ... ``` Due to the change that we made, solver suggested some new dependencies. By default it does not make changes to the config. As it suggested you can use `--update-config` to make changes to the config. NOTE: You should probably back up your `stack.yaml` before doing this, such as committing to Git/Mercurial/Darcs. Sometimes, you may want to use specific versions of certain packages for your project. To do that you can fix those versions by specifying them in the extra-deps section and then use `stack solver` to figure out whether it is feasible to use those or what other dependencies are needed as a result. If you want to change the resolver for your project, you can run `stack solver --resolver ` and it will figure out the changes needed for you. Let's see what happens if we change the resolver to an older resolver - lts-2.22: ``` cueball:~/yackage-0.8.0$ stack solver --resolver lts-2.22 # solver failure output ... ``` As you can see, it automatically suggested changes in `extra-deps` due to the change of resolver. ## Different databases Time to take a short break from hands-on examples and discuss a little architecture. stack has the concept of multiple *databases*. A database consists of a GHC package database (which contains the compiled version of a library), executables, and a few other things as well. To give you an idea: ``` michael@d30748af6d3d:~/helloworld$ ls .stack-work/install/x86_64-linux/lts-3.2/7.10.2/ bin doc flag-cache lib pkgdb ``` Databases in stack are *layered*. For example, the database listing we just gave is called a *local* database. That is layered on top of a *snapshot* database, which contains the libraries and executables specified in the snapshot itself. Finally, GHC itself ships with a number of libraries and executables, which forms the *global* database. To get a quick idea of this, we can look at the output of the `stack exec -- ghc-pkg list` command in our helloworld project: ``` /home/michael/.stack/programs/x86_64-linux/ghc-7.10.2/lib/ghc-7.10.2/package.conf.d Cabal-1.22.4.0 array-0.5.1.0 base-4.8.1.0 bin-package-db-0.0.0.0 binary-0.7.5.0 bytestring-0.10.6.0 containers-0.5.6.2 deepseq-1.4.1.1 directory-1.2.2.0 filepath-1.4.0.0 ghc-7.10.2 ghc-prim-0.4.0.0 haskeline-0.7.2.1 hoopl-3.10.0.2 hpc-0.6.0.2 integer-gmp-1.0.0.0 pretty-1.1.2.0 process-1.2.3.0 rts-1.0 template-haskell-2.10.0.0 terminfo-0.4.0.1 time-1.5.0.1 transformers-0.4.2.0 unix-2.7.1.0 xhtml-3000.2.1 /home/michael/.stack/snapshots/x86_64-linux/nightly-2015-08-26/7.10.2/pkgdb stm-2.4.4 /home/michael/helloworld/.stack-work/install/x86_64-linux/nightly-2015-08-26/7.10.2/pkgdb acme-missiles-0.3 helloworld-0.1.0.0 ``` Notice that acme-missiles ends up in the *local* database. Anything which is not installed from a snapshot ends up in the local database. This includes: your own code, extra-deps, and in some cases even snapshot packages, if you modify them in some way. The reason we have this structure is that: * it lets multiple projects reuse the same binary builds of many snapshot packages, * but doesn't allow different projects to "contaminate" each other by putting non-standard content into the shared snapshot database Typically, the process by which a snapshot package is marked as modified is referred to as "promoting to an extra-dep," meaning we treat it just like a package in the extra-deps section. This happens for a variety of reasons, including: * changing the version of the snapshot package * changing build flags * one of the packages that the package depends on has been promoted to an extra-dep As you probably guessed, there are multiple snapshot databases available, e.g.: ``` michael@d30748af6d3d:~/helloworld$ ls ~/.stack/snapshots/x86_64-linux/ lts-2.22 lts-3.1 lts-3.2 nightly-2015-08-26 ``` These databases don't get layered on top of each other; they are each used separately. In reality, you'll rarely — if ever — interact directly with these databases, but it's good to have a basic understanding of how they work so you can understand why rebuilding may occur at different points. ## The build synonyms Let's look at a subset of the `stack --help` output: ``` build Build the package(s) in this directory/configuration install Shortcut for 'build --copy-bins' test Shortcut for 'build --test' bench Shortcut for 'build --bench' haddock Shortcut for 'build --haddock' ``` Note that four of these commands are just synonyms for the `build` command. They are provided for convenience for common cases (e.g., `stack test` instead of `stack build --test`) and so that commonly expected commands just work. What's so special about these commands being synonyms? It allows us to make much more composable command lines. For example, we can have a command that builds executables, generates Haddock documentation (Haskell API-level docs), and builds and runs your test suites, with: ``` stack build --haddock --test ``` You can even get more inventive as you learn about other flags. For example, take the following: ``` stack build --pedantic --haddock --test --exec "echo Yay, it succeeded" --file-watch ``` This will: * turn on all warnings and errors * build your library and executables * generate Haddocks * build and run your test suite * run the command `echo Yay, it succeeded` when that completes * after building, watch for changes in the files used to build the project, and kick off a new build when done ### install and copy-bins It's worth calling out the behavior of the install command and `--copy-bins` option, since this has confused a number of users (especially when compared to behavior of other tools like cabal-install). The `install` command does precisely one thing in addition to the build command: it copies any generated executables to the local bin path. You may recognize the default value for that path: ``` michael@d30748af6d3d:~/helloworld$ stack path --local-bin /home/michael/.local/bin ``` That's why the download page recommends adding that directory to your `PATH` environment variable. This feature is convenient, because now you can simply run `executable-name` in your shell instead of having to run `stack exec executable-name` from inside your project directory. Since it's such a point of confusion, let me list a number of things stack does *not* do specially for the install command: * stack will always build any necessary dependencies for your code. The install command is not necessary to trigger this behavior. If you just want to build a project, run `stack build`. * stack will *not* track which files it's copied to your local bin path nor provide a way to automatically delete them. There are many great tools out there for managing installation of binaries, and stack does not attempt to replace those. * stack will not necessarily be creating a relocatable executable. If your executables hard-codes paths, copying the executable will not change those hard-coded paths. * At the time of writing, there's no way to change those kinds of paths with stack, but see [issue #848 about --prefix](https://github.com/commercialhaskell/stack/issues/848) for future plans. That's really all there is to the install command: for the simplicity of what it does, it occupies a much larger mental space than is warranted. ## Targets, locals, and extra-deps We haven't discussed this too much yet, but, in addition to having a number of synonyms *and* taking a number of options on the command line, the build command *also* takes many arguments. These are parsed in different ways, and can be used to achieve a high level of flexibility in telling stack exactly what you want to build. We're not going to cover the full generality of these arguments here; instead, there's [documentation covering the full build command syntax](build_command.md). Here, we'll just point out a few different types of arguments: * You can specify a *package name*, e.g. `stack build vector`. * This will attempt to build the vector package, whether it's a local package, in your extra-deps, in your snapshot, or just available upstream. If it's just available upstream but not included in your locals, extra-deps, or snapshot, the newest version is automatically promoted to an extra-dep. * You can also give a *package identifier*, which is a package name plus version, e.g. `stack build yesod-bin-1.4.14`. * This is almost identical to specifying a package name, except it will (1) choose the given version instead of latest, and (2) error out if the given version conflicts with the version of a local package. * The most flexibility comes from specifying individual *components*, e.g. `stack build helloworld:test:helloworld-test` says "build the test suite component named helloworld-test from the helloworld package." * In addition to this long form, you can also shorten it by skipping what type of component it is, e.g. `stack build helloworld:helloworld-test`, or even skip the package name entirely, e.g. `stack build :helloworld-test`. * Finally, you can specify individual *directories* to build to trigger building of any local packages included in those directories or subdirectories. When you give no specific arguments on the command line (e.g., `stack build`), it's the same as specifying the names of all of your local packages. If you just want to build the package for the directory you're currently in, you can use `stack build .`. ### Components, --test, and --bench Here's one final important yet subtle point. Consider our helloworld package: it has a library component, an executable helloworld-exe, and a test suite helloworld-test. When you run `stack build helloworld`, how does it know which ones to build? By default, it will build the library (if any) and all of the executables but ignore the test suites and benchmarks. This is where the `--test` and `--bench` flags come into play. If you use them, those components will also be included. So `stack build --test helloworld` will end up including the helloworld-test component as well. You can bypass this implicit adding of components by being much more explicit, and stating the components directly. For example, the following will not build the helloworld-exe executable: ``` michael@d30748af6d3d:~/helloworld$ stack clean michael@d30748af6d3d:~/helloworld$ stack build :helloworld-test helloworld-0.1.0.0: configure (test) Configuring helloworld-0.1.0.0... helloworld-0.1.0.0: build (test) Preprocessing library helloworld-0.1.0.0... [1 of 1] Compiling Lib ( src/Lib.hs, .stack-work/dist/x86_64-linux/Cabal-1.22.4.0/build/Lib.o ) In-place registering helloworld-0.1.0.0... Preprocessing test suite 'helloworld-test' for helloworld-0.1.0.0... [1 of 1] Compiling Main ( test/Spec.hs, .stack-work/dist/x86_64-linux/Cabal-1.22.4.0/build/helloworld-test/helloworld-test-tmp/Main.o ) Linking .stack-work/dist/x86_64-linux/Cabal-1.22.4.0/build/helloworld-test/helloworld-test ... helloworld-0.1.0.0: test (suite: helloworld-test) Test suite not yet implemented ``` We first cleaned our project to clear old results so we know exactly what stack is trying to do. Notice that it builds the helloworld-test test suite, and the helloworld library (since it's used by the test suite), but it does not build the helloworld-exe executable. And now the final point: the last line shows that our command also *runs* the test suite it just built. This may surprise some people who would expect tests to only be run when using `stack test`, but this design decision is what allows the `stack build` command to be as composable as it is (as described previously). The same rule applies to benchmarks. To spell it out completely: * The --test and --bench flags simply state which components of a package should be built, if no explicit set of components is given * The default behavior for any test suite or benchmark component which has been built is to also run it You can use the `--no-run-tests` and `--no-run-benchmarks` (from stack-0.1.4.0 and on) flags to disable running of these components. You can also use `--no-rerun-tests` to prevent running a test suite which has already passed and has not changed. NOTE: stack doesn't build or run test suites and benchmarks for non-local packages. This is done so that running a command like `stack test` doesn't need to run 200 test suites! ## Multi-package projects Until now, everything we've done with stack has used a single-package project. However, stack's power truly shines when you're working on multi-package projects. All the functionality you'd expect to work just does: dependencies between packages are detected and respected, dependencies of all packages are just as one cohesive whole, and if anything fails to build, the build commands exits appropriately. Let's demonstrate this with the wai-app-static and yackage packages: ``` michael@d30748af6d3d:~$ mkdir multi michael@d30748af6d3d:~$ cd multi/ michael@d30748af6d3d:~/multi$ stack unpack wai-app-static-3.1.1 yackage-0.8.0 wai-app-static-3.1.1: download Unpacked wai-app-static-3.1.1 to /home/michael/multi/wai-app-static-3.1.1/ Unpacked yackage-0.8.0 to /home/michael/multi/yackage-0.8.0/ michael@d30748af6d3d:~/multi$ stack init Writing default config file to: /home/michael/multi/stack.yaml Basing on cabal files: - /home/michael/multi/yackage-0.8.0/yackage.cabal - /home/michael/multi/wai-app-static-3.1.1/wai-app-static.cabal Checking against build plan lts-3.2 Selected resolver: lts-3.2 Wrote project config to: /home/michael/multi/stack.yaml michael@d30748af6d3d:~/multi$ stack build --haddock --test # Goes off to build a whole bunch of packages ``` If you look at the `stack.yaml`, you'll see exactly what you'd expect: ```yaml flags: yackage: upload: true wai-app-static: print: false packages: - yackage-0.8.0/ - wai-app-static-3.1.1/ extra-deps: [] resolver: lts-3.2 ``` Notice that multiple directories are listed in the `packages` key. In addition to local directories, you can also refer to packages available in a Git repository or in a tarball over HTTP/HTTPS. This can be useful for using a modified version of a dependency that hasn't yet been released upstream. Please note that when adding upstream packages directly to your project it is important to distinguish _local packages_ from the upstream _dependency packages_. Otherwise you may have trouble running `stack ghci`. See [stack.yaml documentation](yaml_configuration.md#packages) for more details. ## Flags and GHC options There are two common ways to alter how a package will install: with Cabal flags and with GHC options. ### Cabal flag management In the `stack.yaml` file above, you can see that `stack init` has detected that — for the yackage package — the upload flag can be set to true, and for wai-app-static, the print flag to false (it's chosen those values because they're the default flag values, and their dependencies are compatible with the snapshot we're using.) To change a flag setting, we can use the command line `--flag` option: stack build --flag yackage:-upload This means: when compiling the yackage package, turn off the upload flag (thus the `-`). Unlike other tools, stack is explicit about which package's flag you want to change. It does this for two reasons: 1. There's no global meaning for Cabal flags, and therefore two packages can use the same flag name for completely different things. 2. By following this approach, we can avoid unnecessarily recompiling snapshot packages that happen to use a flag that we're using. You can also change flag values on the command line for extra-dep and snapshot packages. If you do this, that package will automatically be promoted to an extra-dep, since the build plan is different than what the plan snapshot definition would entail. ### GHC options GHC options follow a similar logic as in managing Cabal flags, with a few nuances to adjust for common use cases. Let's consider: stack build --ghc-options="-Wall -Werror" This will set the `-Wall -Werror` options for all *local targets*. Note that this will not affect extra-dep and snapshot packages at all. This design provides us with reproducible and fast builds. (By the way: the above GHC options have a special convenience flag: `--pedantic`.) There's one extra nuance about command line GHC options: Since they only apply to local targets, if you change your local targets, they will no longer apply to other packages. Let's play around with an example from the wai repository, which includes the wai and warp packages, the latter depending on the former. If we run: stack build --ghc-options=-O0 wai It will build all of the dependencies of wai, and then build wai with all optimizations disabled. Now let's add in warp as well: stack build --ghc-options=-O0 wai warp This builds the additional dependencies for warp, and then builds warp with optimizations disabled. Importantly: it does not rebuild wai, since wai's configuration has not been altered. Now the surprising case: ``` michael@d30748af6d3d:~/wai$ stack build --ghc-options=-O0 warp wai-3.0.3.0-5a49351d03cba6cbaf906972d788e65d: unregistering (flags changed from ["--ghc-options","-O0"] to []) warp-3.1.3-a91c7c3108f63376877cb3cd5dbe8a7a: unregistering (missing dependencies: wai) wai-3.0.3.0: configure ``` You may expect this to be a no-op: neither wai nor warp has changed. However, stack will instead recompile wai with optimizations enabled again, and then rebuild warp (with optimizations disabled) against this newly built wai. The reason: reproducible builds. If we'd never built wai or warp before, trying to build warp would necessitate building all of its dependencies, and it would do so with default GHC options (optimizations enabled). This dependency would include wai. So when we run: stack build --ghc-options=-O0 warp We want its behavior to be unaffected by any previous build steps we took. While this specific corner case does catch people by surprise, the overall goal of reproducible builds is- in the stack maintainers' views- worth the confusion. Final point: if you have GHC options that you'll be regularly passing to your packages, you can add them to your `stack.yaml` file (starting with stack-0.1.4.0). See [the documentation section on ghc-options](yaml_configuration.md#ghc-options) for more information. ## path NOTE: That's it, the heavy content of this guide is done! Everything from here on out is simple explanations of commands. Congratulations! Generally, you don't need to worry about where stack stores various files. But some people like to know this stuff. That's when the `stack path` command is useful. ``` michael@d30748af6d3d:~/wai$ stack path global-stack-root: /home/michael/.stack stack-root: /home/michael/.stack project-root: /home/michael/wai config-location: /home/michael/wai/stack.yaml bin-path: /home/michael/.stack/snapshots/x86_64-linux/lts-2.17/7.8.4/bin:/home/michael/.stack/programs/x86_64-linux/ghc-7.8.4/bin:/home/michael/.stack/programs/x86_64-linux/ghc-7.10.2/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin programs: /home/michael/.stack/programs/x86_64-linux compiler: /home/michael/.stack/programs/x86_64-linux/ghc-7.8.4/bin/ghc compiler-bin: /home/michael/.stack/programs/x86_64-linux/ghc-7.8.4/bin local-bin-path: /home/michael/.local/bin extra-include-dirs: extra-library-dirs: snapshot-pkg-db: /home/michael/.stack/snapshots/x86_64-linux/lts-2.17/7.8.4/pkgdb local-pkg-db: /home/michael/wai/.stack-work/install/x86_64-linux/lts-2.17/7.8.4/pkgdb global-pkg-db: /home/michael/.stack/programs/x86_64-linux/ghc-7.8.4/lib/ghc-7.8.4/package.conf.d ghc-package-path: /home/michael/wai/.stack-work/install/x86_64-linux/lts-2.17/7.8.4/pkgdb:/home/michael/.stack/snapshots/x86_64-linux/lts-2.17/7.8.4/pkgdb:/home/michael/.stack/programs/x86_64-linux/ghc-7.8.4/lib/ghc-7.8.4/package.conf.d snapshot-install-root: /home/michael/.stack/snapshots/x86_64-linux/lts-2.17/7.8.4 local-install-root: /home/michael/wai/.stack-work/install/x86_64-linux/lts-2.17/7.8.4 snapshot-doc-root: /home/michael/.stack/snapshots/x86_64-linux/lts-2.17/7.8.4/doc local-doc-root: /home/michael/wai/.stack-work/install/x86_64-linux/lts-2.17/7.8.4/doc dist-dir: .stack-work/dist/x86_64-linux/Cabal-1.18.1.5 local-hpc-root: /home/michael/wai/.stack-work/install/x86_64-linux/lts-2.17/7.8.4/hpc ``` In addition, `stack path` accepts command line arguments to state which of these keys you're interested in, which can be convenient for scripting. As a simple example, let's find out the sandboxed versions of GHC that stack installed: ``` michael@d30748af6d3d:~/wai$ ls $(stack path --programs)/*.installed /home/michael/.stack/programs/x86_64-linux/ghc-7.10.2.installed /home/michael/.stack/programs/x86_64-linux/ghc-7.8.4.installed ``` (Yes, that command requires a \*nix shell, and likely won't run on Windows.) While we're talking about paths, to wipe our stack install completely, here's what needs to be removed: 1. The stack executable itself 2. The stack root, e.g. `$HOME/.stack` on non-Windows systems. * See `stack path --stack-root` * On Windows, you will also need to delete `stack path --programs` 3. Any local `.stack-work` directories inside a project ## exec We've already used `stack exec` multiple times in this guide. As you've likely already guessed, it allows you to run executables, but with a slightly modified environment. In particular: `stack exec` looks for executables on stack's bin paths, and sets a few additional environment variables (like adding those paths to `PATH`, and setting `GHC_PACKAGE_PATH`, which tells GHC which package databases to use). If you want to see exactly what the modified environment looks like, try: stack exec env The only issue is how to distinguish flags to be passed to stack versus those for the underlying program. Thanks to the optparse-applicative library, stack follows the Unix convention of `--` to separate these, e.g.: ``` michael@d30748af6d3d:~$ stack exec --package stm -- echo I installed the stm package via --package stm Run from outside a project, using implicit global project config Using latest snapshot resolver: lts-3.2 Writing global (non-project-specific) config file to: /home/michael/.stack/global/stack.yaml Note: You can change the snapshot via the resolver field there. I installed the stm package via --package stm ``` Flags worth mentioning: * `--package foo` can be used to force a package to be installed before running the given command. * `--no-ghc-package-path` can be used to stop the `GHC_PACKAGE_PATH` environment variable from being set. Some tools — notably cabal-install — do not behave well with that variable set. ## ghci (the repl) GHCi is the interactive GHC environment, a.k.a. the REPL. You *could* access it with: stack exec ghci But that won't load up locally written modules for access. For that, use the `stack ghci` command. To then load modules from your project, use the `:m` command (for "module") followed by the module name. IMPORTANT NOTE: If you have added upstream packages to your project please make sure to mark them as *dependency package*s for faster and reliable usage of `stack ghci`. Otherwise GHCi may have trouble due to conflicts of compilation flags or having to unnecessarily interpret too many modules. See [stack.yaml documentation](yaml_configuration.md#packages) to learn how to mark a package as a *dependency package*. ## ghc/runghc You'll sometimes want to just compile (or run) a single Haskell source file, instead of creating an entire Cabal package for it. You can use `stack exec ghc` or `stack exec runghc` for that. As simple helpers, we also provide the `stack ghc` and `stack runghc` commands, for these common cases. ## script interpreter stack also offers a very useful feature for running files: a script interpreter. For too long have Haskellers felt shackled to bash or Python because it's just too hard to create reusable source-only Haskell scripts. stack attempts to solve that. You can use `stack ` to execute a Haskell source file or specify `stack` as the interpreter using a shebang line on a Unix like operating systems. Additional stack options can be specified using a special Haskell comment in the source file to specify dependencies and automatically install them before running the file. An example will be easiest to understand: ``` michael@d30748af6d3d:~$ cat turtle-example.hs #!/usr/bin/env stack -- stack --resolver lts-6.25 script --package turtle {-# LANGUAGE OverloadedStrings #-} import Turtle main = echo "Hello World!" michael@d30748af6d3d:~$ chmod +x turtle-example.hs michael@d30748af6d3d:~$ ./turtle-example.hs Completed 5 action(s). Hello World! michael@d30748af6d3d:~$ ./turtle-example.hs Hello World! ``` The first run can take a while (as it has to download GHC if necessary and build dependencies), but subsequent runs are able to reuse everything already built, and are therefore quite fast. The first line in the source file is the usual "shebang" to use stack as a script interpreter. The second line, is a Haskell comment providing additional options to stack (due to the common limitation of the "shebang" line only being allowed a single argument). In this case, the options tell stack to use the lts-3.2 resolver, automatically install GHC if it is not already installed, and ensure the turtle package is available. If you're on Windows: you can run `stack turtle.hs` instead of `./turtle.hs`. The shebang line is not required in that case. ### Using multiple packages You can also specify multiple packages, either with multiple `--package` arguments, or by providing a comma or space separated list. For example: ``` #!/usr/bin/env stack {- stack script --resolver lts-6.25 --package turtle --package "stm async" --package http-client,http-conduit -} ``` ### Stack configuration for scripts With the `script` command, all Stack configuration files are ignored to provide a completely reliable script running experience. However, see the example below with `runghc` for an approach to scripts which will respect your configuration files. When using `runghc`, if the current working directory is inside a project then that project's stack configuration is effective when running the script. Otherwise the script uses the global project configuration specified in `~/.stack/global-project/stack.yaml`. ### Specifying interpreter options The stack interpreter options comment must specify a single valid stack command line, starting with `stack` as the command followed by the stack options to use for executing this file. The comment must always be on the line immediately following the shebang line when the shebang line is present otherwise it must be the first line in the file. The comment must always start in the first column of the line. When many options are needed a block style comment may be more convenient to split the command on multiple lines for better readability. You can also specify ghc options the same way as you would on command line i.e. by separating the stack options and ghc options with a `--`. Here is an example of a multi line block comment with ghc options: ``` #!/usr/bin/env stack {- stack script --resolver lts-6.25 --package turtle -- +RTS -s -RTS -} ``` ### Writing independent and reliable scripts With the release of Stack 1.4.0, there is a new command, `script`, which will automatically: * Install GHC and libraries if missing * Require that all packages used be explicitly stated on the command line This ensures that your scripts are _independent_ of any prior deployment specific configuration, and are _reliable_ by using exactly the same version of all packages every time it runs so that the script does not break by accidentally using incompatible package versions. In previous versions of Stack, the `runghc` command was used for scripts instead. In order to achieve the same effect with the `runghc` command, you can do the following: 1. Use the `--install-ghc` option to install the compiler automatically 2. Explicitly specify all packages required by the script using the `--package` option. Use `-hide-all-packages` ghc option to force explicit specification of all packages. 3. Use the `--resolver` Stack option to ensure a specific GHC version and package set is used. Even with this configuration, it is still possible for configuration files to impact `stack runghc`, which is why `stack script` is strongly recommended in general. For those curious, here is an example with `runghc`: ``` #!/usr/bin/env stack {- stack --resolver lts-6.25 --install-ghc runghc --package base --package turtle -- -hide-all-packages -} ``` The `runghc` command is still very useful, especially when you're working on a project and want to access the package databases and configurations used by that project. See the next section for more information on configuration files. ### Loading scripts in ghci Sometimes you want to load your script in ghci REPL to play around with your program. In those cases, you can use `exec ghci` option in the script to achieve it. Here is an example: ``` #!/usr/bin/env stack {- stack --resolver lts-8.2 --install-ghc exec ghci --package text -} ``` ## Finding project configs, and the implicit global project Whenever you run something with stack, it needs a `stack.yaml` project file. The algorithm stack uses to find this is: 1. Check for a `--stack-yaml` option on the command line 2. Check for a `STACK_YAML` environment variable 3. Check the current directory and all ancestor directories for a `stack.yaml` The first two provide a convenient method for using an alternate configuration. For example: `stack build --stack-yaml stack-7.8.yaml` can be used by your CI system to check your code against GHC 7.8. Setting the `STACK_YAML` environment variable can be convenient if you're going to be running commands like `stack ghc` in other directories, but you want to use the configuration you defined in a specific project. If stack does not find a `stack.yaml` in any of the three specified locations, the *implicit global* logic kicks in. You've probably noticed that phrase a few times in the output from commands above. Implicit global is essentially a hack to allow stack to be useful in a non-project setting. When no implicit global config file exists, stack creates one for you with the latest LTS snapshot as the resolver. This allows you to do things like: * compile individual files easily with `stack ghc` * build executables without starting a project, e.g. `stack install pandoc` Keep in mind that there's nothing magical about this implicit global configuration. It has no impact on projects at all. Every package you install with it is put into isolated databases just like everywhere else. The only magic is that it's the catch-all project whenever you're running stack somewhere else. ## Setting stack root location `stack path --stack-root` will tell you the location of the "stack root". Among other things, this is where stack stores downloaded programs and snapshot packages. This location can be configured by setting the STACK_ROOT environment variable or passing the `--stack-root` commandline option. It is particularly useful to do this on Windows, where filepaths are limited (MAX_PATH), and things can break when this limit is exceeded. ## `stack.yaml` vs `.cabal` files Now that we've covered a lot of stack use cases, this quick summary of `stack.yaml` vs `.cabal` files will hopefully make sense and be a good reminder for future uses of stack: * A project can have multiple packages. * Each project has a `stack.yaml`. * Each package has a `.cabal` file. * The `.cabal` file specifies which packages are dependencies. * The `stack.yaml` file specifies which packages are available to be used. * `.cabal` specifies the components, modules, and build flags provided by a package * `stack.yaml` can override the flag settings for individual packages * `stack.yaml` specifies which packages to include ## Comparison to other tools stack is not the only tool around for building Haskell code. stack came into existence due to limitations with some of the existing tools. If you're unaffected by those limitations and are happily building Haskell code, you may not need stack. If you're suffering from some of the common problems in other tools, give stack a try instead. If you're a new user who has no experience with other tools, we recommend going with stack. The defaults match modern best practices in Haskell development, and there are less corner cases you need to be aware of. You *can* develop Haskell code with other tools, but you probably want to spend your time writing code, not convincing a tool to do what you want. Before jumping into the differences, let me clarify an important similarity: __Same package format.__ stack, cabal-install, and presumably all other tools share the same underlying Cabal package format, consisting of a `.cabal` file, modules, etc. This is a Good Thing: we can share the same set of upstream libraries, and collaboratively work on the same project with stack, cabal-install, and NixOS. In that sense, we're sharing the same ecosystem. Now the differences: * __Curation vs dependency solving as a default__. * stack defaults to using curation (Stackage snapshots, LTS Haskell, Nightly, etc) as a default instead of defaulting to dependency solving, as cabal-install does. This is just a default: as described above, stack can use dependency solving if desired, and cabal-install can use curation. However, most users will stick to the defaults. The stack team firmly believes that the majority of users want to simply ignore dependency resolution nightmares and get a valid build plan from day 1, which is why we've made this selection of default behavior. * __Reproducible__. * stack goes to great lengths to ensure that `stack build` today does the same thing tomorrow. cabal-install does not: build plans can be affected by the presence of preinstalled packages, and running `cabal update` can cause a previously successful build to fail. With stack, changing the build plan is always an explicit decision. * __Automatically building dependencies__. * In cabal-install, you need to use `cabal install` to trigger dependency building. This is somewhat necessary due to the previous point, since building dependencies can, in some cases, break existing installed packages. So for example, in stack, `stack test` does the same job as `cabal install --run-tests`, though the latter *additionally* performs an installation that you may not want. The closer command equivalent is `cabal install --enable-tests --only-dependencies && cabal configure --enable-tests && cabal build && cabal test` (newer versions of cabal-install may make this command shorter). * __Isolated by default__. * This has been a pain point for new stack users. In cabal, the default behavior is a non-isolated build where working on two projects can cause the user package database to become corrupted. The cabal solution to this is sandboxes. stack, however, provides this behavior by default via its databases. In other words: when you use stack, there's __no need for sandboxes__, everything is (essentially) sandboxed by default. __Other tools for comparison (including active and historical)__ * [cabal-dev](https://hackage.haskell.org/package/cabal-dev) (deprecated in favor of cabal-install) * [cabal-meta](https://hackage.haskell.org/package/cabal-meta) inspired a lot of the multi-package functionality of stack. If you're still using cabal-install, cabal-meta is relevant. For stack work, the feature set is fully subsumed by stack. * [cabal-src](https://hackage.haskell.org/package/cabal-src) is mostly irrelevant in the presence of both stack and cabal sandboxes, both of which make it easier to add additional package sources easily. The mega-sdist executable that ships with cabal-src is, however, still relevant. Its functionality may some day be folded into stack * [stackage-cli](https://hackage.haskell.org/package/stackage-cli) was an initial attempt to make cabal-install work more easily with curated snapshots, but due to a slight impedance mismatch between cabal.config constraints and snapshots, it did not work as well as hoped. It is deprecated in favor of stack. ## Fun features This is just a quick collection of fun and useful feature stack supports. ### Templates We started off using the `new` command to create a project. stack provides multiple templates to start a new project from: ``` michael@d30748af6d3d:~$ stack templates # Stack Templates The `stack new` command will create a new project based on a project template. Templates can be located on the local filesystem, on Github, or arbitrary URLs. For more information, please see the user guide: https://docs.haskellstack.org/en/stable/GUIDE/#templates There are many templates available, some simple examples: stack new myproj # uses the default template stack new myproj2 rio # uses the rio template stack new website yesodweb/sqlite # Yesod server with SQLite DB For more information and other templates, please see the `stack-templates` Wiki: https://github.com/commercialhaskell/stack-templates/wiki Please feel free to add your own templates to the Wiki for discoverability. Want to improve this text? Send us a PR! https://github.com/commercialhaskell/stack-templates/edit/master/STACK_HELP.md ``` You can specify one of these templates following your project name in the `stack new` command: ``` michael@d30748af6d3d:~$ stack new my-yesod-project yesodweb/simple Downloading template "yesod-simple" to create project "my-yesod-project" in my-yesod-project/ ... Using the following authorship configuration: author-email: example@example.com author-name: Example Author Name Copy these to /home/michael/.stack/config.yaml and edit to use different values. Writing default config file to: /home/michael/my-yesod-project/stack.yaml Basing on cabal files: - /home/michael/my-yesod-project/my-yesod-project.cabal Checking against build plan lts-3.2 Selected resolver: lts-3.2 Wrote project config to: /home/michael/my-yesod-project/stack.yaml ``` The default `stack-templates` repository is on [Github](https://github.com/commercialhaskell/stack-templates), under the user account `commercialstack`. You can download templates from a different Github user by prefixing the username and a slash: ``` stack new my-yesod-project yesodweb/simple ``` Then it would be downloaded from Github, user account `yesodweb`, repo `stack-templates`, and file `yesod-simple.hsfiles`. You can even download templates from a service other that Github, such as [Gitlab](https://gitlab.com) or [Bitbucket](https://bitbucket.com): ``` stack new my-project gitlab:user29/foo ``` That template would be downloaded from Gitlab, user account `user29`, repo `stack-templates`, and file `foo.hsfiles`. If you need more flexibility, you can specify the full URL of the template: ``` stack new my-project https://my-site.com/content/template9.hsfiles ``` (The `.hsfiles` extension is optional; it will be added if it's not specified.) Alternatively you can use a local template by specifying the path: ``` stack new project ~/location/of/your/template.hsfiles ``` As a starting point for creating your own templates, you can use [the "simple" template](https://github.com/commercialhaskell/stack-templates/blob/master/simple.hsfiles). An introduction into template-writing and a place for submitting official templates, you will find at [the stack-templates repository](https://github.com/commercialhaskell/stack-templates#readme). ### Editor integration For editor integration, stack has a related project called [intero](https://github.com/commercialhaskell/intero). It is particularly well supported by emacs, but some other editors have integration for it as well. ### Visualizing dependencies If you'd like to get some insight into the dependency tree of your packages, you can use the `stack dot` command and Graphviz. More information is [available in the Dependency visualization documentation](dependency_visualization.md). ### Travis with caching This content has been moved to a dedicated [Travis CI document](https://docs.haskellstack.org/en/stable/travis_ci/). ### Shell auto-completion Love tab-completion of commands? You're not alone. If you're on bash, just run the following (or add it to `.bashrc`): eval "$(stack --bash-completion-script stack)" For more information and other shells, see [the Shell auto-completion wiki page](https://docs.haskellstack.org/en/stable/shell_autocompletion) ### Docker stack provides two built-in Docker integrations. The first way is to build your code inside a Docker image, which means: * even more reproducibility to your builds, since you and the rest of your team will always have the same system libraries * the Docker images ship with entire precompiled snapshots. That means you have a large initial download, but much faster builds The second way is to generate Docker images for you containing your built executables (the executable is built in your local machine and copied into the image) . This feature is great for automating deployments from CI. This feature is not yet well-documented, but the basics are to add a section like the following to stack.yaml: ```yaml image: # You need a `containers` yaml section for `stack image container`. # A `container` section that does not contain a list is also valid. containers: # This example just has one container. - # You need a base image name. Stack layers exes on top of # the base image. Prepare your project image in advance by # putting all your runtime dependencies in the image. base: "fpco/ubuntu-with-libgmp:14.04" # You can optionally name the image. Stack will use the project # directory name if you leave out this option. name: "fpco/hello-world" # Optionally add a directory to a path inside the docker image. add: man/: /usr/local/share/man/ # Optionally specify a list of executables. Stack will create # a tagged image for each in the list. these images will have # their respective "ENTRYPOINT" set. entrypoints: - stack ``` and then run `stack image container` and then `docker images` to list the images. Note that the executable will be built in the development environment and copied to the container, so the dev OS must match that of the container OS. Note that you can use the `--docker` option to build your code inside the Docker container in case you have a different development environment or if you specifically want to build on the container. The executable will be stored under `/usr/local/bin/-exe` in the running container. If you want the container to run the executable immediately on startup then set an entrypoint as follows: ```yaml entrypoints: - -exe ``` The difference between the first and second integration methods is that in the first one your Haskell code is actually built in the container whereas in the second one the executable built in your host machine is copied to the container. The presence of the following configuration in `stack.yaml` informs stack to switch to the first integration method: ```yaml docker: enable: true ``` Alternatively, instead of the above configuration, you can use the `--docker` option to achieve the same. You can find more details about the first integration method [in the Docker integration documentation](./docker_integration.md). ### Nix stack provides an integration with [Nix](http://nixos.org/nix), providing you with the same two benefits as the first Docker integration discussed above: * more reproducible builds, since fixed versions of any system libraries and commands required to build the project are automatically built using Nix and managed locally per-project. These system packages never conflict with any existing versions of these libraries on your system. That they are managed locally to the project means that you don't need to alter your system in any way to build any odd project pulled from the Internet. * implicit sharing of system packages between projects, so you don't have more copies on-disk than you need to. When using the Nix integration, Stack downloads and builds Haskell dependencies as usual, but resorts on Nix to provide non-Haskell dependencies that exist in the Nixpkgs. Both Docker and Nix are methods to *isolate* builds and thereby make them more reproducible. They just differ in the means of achieving this isolation. Nix provides slightly weaker isolation guarantees than Docker, but is more lightweight and more portable (Linux and OS X mainly, but also Windows). For more on Nix, its command-line interface and its package description language, read the [Nix manual](http://nixos.org/nix/manual). But keep in mind that the point of stack's support is to obviate the need to write any Nix code in the common case or even to learn how to use the Nix tools (they're called under the hood). For more information, see [the Nix-integration documentation](nix_integration.md). ## Power user commands The following commands are a little more powerful, and won't be needed by all users. Here's a quick rundown: * `stack update` will download the most recent set of packages from your package indices (e.g. Hackage). Generally, stack runs this for you automatically when necessary, but it can be useful to do this manually sometimes (e.g., before running `stack solver`, to guarantee you have the most recent upstream packages available). * `stack unpack` is a command we've already used quite a bit for examples, but most users won't use it regularly. It does what you'd expect: downloads a tarball and unpacks it. It accept optional `--to` argument to specify the destination directory. * `stack sdist` generates an uploading tarball containing your package code * `stack upload` uploads an sdist to Hackage. As of version [1.1.0](https://docs.haskellstack.org/en/v1.1.0/ChangeLog/) stack will also attempt to GPG sign your packages as per [our blog post](https://www.fpcomplete.com/blog/2016/05/stack-security-gnupg-keys). * `--no-signature` disables signing of packages * `stack upgrade` will build a new version of stack from source. * `--git` is a convenient way to get the most recent version from master for those testing and living on the bleeding edge. * `stack ls snapshots` will list all the local snapshots by default. You can also view the remote snapshots using `stack ls snapshots remote`. It also supports option for viewing only lts (`-l`) and nightly (`-n`) snapshots. * `stack ls dependencies` lists all of the packages and versions used for a project * `stack sig` subcommand can help you with GPG signing & verification * `sign` will sign an sdist tarball and submit the signature to sig.commercialhaskell.org for storage in the sig-archive git repo. (Signatures will be used later to verify package integrity.) ## Debugging To profile a component of the current project, simply pass the `--profile` flag to `stack`. The `--profile` flag turns on the `--enable-library-profiling` and `--enable-executable-profiling` Cabal options _and_ passes the `+RTS -p` runtime options to any testsuites and benchmarks. For example the following command will build the `my-tests` testsuite with profiling options and create a `my-tests.prof` file in the current directory as a result of the test run. stack test --profile my-tests The `my-tests.prof` file now contains time and allocation info for the test run. To create a profiling report for an executable, e.g. `my-exe`, you can run stack exec -- my-exe +RTS -p For more fine-grained control of compilation options there are the `--library-profiling` and `--executable-profiling` flags which will turn on the `--enable-library-profiling` and `--enable-executable-profiling` Cabal options respectively. Custom GHC options can be passed in with `--ghc-options "more options here"`. To enable compilation with profiling options by default you can add the following snippet to your `stack.yaml` or `~/.stack/config.yaml`: ``` build: library-profiling: true executable-profiling: true ``` ### Further reading For more commands and uses, see [the official GHC chapter on profiling](https://downloads.haskell.org/~ghc/latest/docs/html/users_guide/profiling.html), [the Haskell wiki](https://wiki.haskell.org/How_to_profile_a_Haskell_program), and [the chapter on profiling in Real World Haskell](http://book.realworldhaskell.org/read/profiling-and-optimization.html). ### Tracing To generate a backtrace in case of exceptions during a test or benchmarks run, use the `--trace` flag. Like `--profile` this compiles with profiling options, but adds the `+RTS -xc` runtime option. ### DWARF `stack` now supports debugging and profiling with [DWARF information](https://ghc.haskell.org/trac/ghc/wiki/DWARF), using the `--no-strip`, `--no-library-stripping`, and `--no-executable-stripping` flags to disable the default behavior of removing such information from compiled libraries and executables. ## More resources There are lots of resources available for learning more about stack: * `stack --help` * `stack --version` — identify the version and Git hash of the stack executable * `--verbose` (or `-v`) — much more info about internal operations (useful for bug reports) * The [home page](http://haskellstack.org) * The [stack mailing list](https://groups.google.com/d/forum/haskell-stack) * The [FAQ](faq.md) * The [stack wiki](https://github.com/commercialhaskell/stack/wiki) * The [haskell-stack tag on Stack Overflow](http://stackoverflow.com/questions/tagged/haskell-stack) * [Another getting started with stack tutorial](http://seanhess.github.io/2015/08/04/practical-haskell-getting-started.html) * [Why is stack not cabal?](https://www.fpcomplete.com/blog/2015/06/why-is-stack-not-cabal) stack-1.9.3.1/doc/install_and_upgrade.md0000644000000000000000000003603213455666157016272 0ustar0000000000000000
# Install/upgrade For common Un*x operating systems (including macOS), all you need to do is run: curl -sSL https://get.haskellstack.org/ | sh or: wget -qO- https://get.haskellstack.org/ | sh Distribution packages are available for [Ubuntu](#ubuntu), [Debian](#debian), [Fedora](#fedora), [Arch Linux](#arch-linux) and [FreeBSD](#freebsd). Binaries for other operating systems are listed below, and available on [the GitHub release page](https://github.com/fpco/stack/releases). For the future, we are open to supporting more OSes (to request one, please [submit an issue](https://github.com/commercialhaskell/stack/issues/new)). Binary packages are signed with this [signing key](SIGNING_KEY.md). If you are writing a script that needs to download the latest binary, you can use URLs like `https://get.haskellstack.org/stable/.` (e.g. //get.haskellstack.org/stable/linux-x86_64.tar.gz) that always point to the latest stable release. ## Windows We recommend installing to the default location with these installers, as that will make `stack install` and `stack upgrade` work correctly out of the box. * [Windows 64-bit Installer](https://get.haskellstack.org/stable/windows-x86_64-installer.exe) * [Windows 32-bit Installer](https://get.haskellstack.org/stable/windows-i386-installer.exe) If in doubt: you should prefer the 64-bit installer. You may see a "Windows Defender SmartScreen prevented an unrecognized app from starting" warning when you try to run the installer. If so, click on **More info**, and then click on the **Run anyway** button that appears. ### Manual download * Download the latest release: * [Windows 64-bit](https://get.haskellstack.org/stable/windows-x86_64.zip) * [Windows 32-bit](https://get.haskellstack.org/stable/windows-i386.zip) * Unpack the archive and place `stack.exe` somewhere on your `%PATH%` (see [Path section below](#path)) and you can then run `stack` on the command line. * Now you can run `stack` from the terminal. ## macOS We generally test on the current version of macOS and do our best to keep it compatible with the three most recent major versions. Stack may also work on older versions (YMMV). ### Installer script Run: curl -sSL https://get.haskellstack.org/ | sh ### Manual download * Download the latest release: * [macOS 64-bit](https://get.haskellstack.org/stable/osx-x86_64.tar.gz) * Extract the archive and place `stack` somewhere on your `$PATH` (see [Path section below](#path)) * Now you can run `stack` from the terminal. ### Using Homebrew If you have the popular [brew](https://brew.sh/) tool installed, you can just do: brew install stack * The Homebrew formula and bottles are **unofficial** and lag slightly behind new Stack releases, but tend to be updated within a day or two. * Normally, Homebrew will install from a pre-built binary (aka "pour from a bottle"), but if `brew` starts trying to build everything from source (which will take hours), see [their FAQ on the topic](https://github.com/Homebrew/brew/blob/master/docs/FAQ.md#why-do-you-compile-everything). ### Notes After installation, running `stack setup` might fail with `configure: error: cannot run C compiled programs.` in which case you should run: xcode-select --install If you are on OS X 10.11 ("El Capitan") and encounter either of these problems, see the linked FAQ entries: * [GHC 7.8.4 fails with `/usr/bin/ar: permission denied`](faq.md#usr-bin-ar-permission-denied) * [DYLD_LIBRARY_PATH is ignored](faq.md#dyld-library-path-ignored) If you are on OS X 10.12 ("Sierra") and encounter [GHC panic while building, see this issue](https://github.com/commercialhaskell/stack/issues/2577) ## Ubuntu Use the [generic Linux option](#linux). There is also a [Ubuntu package](http://packages.ubuntu.com/search?keywords=haskell-stack&searchon=names&suite=all§ion=all) for Ubuntu 16.10 and up, but the distribution's Stack version lags behind, so we recommend running `stack upgrade --binary-only` after installing it. For older stack versions which do not support `--binary-only`, just `stack upgrade` may work too. The version in Ubuntu 16.04 is too old to upgrade successfully, and so in that case stack should be installed from a [release tarball](https://github.com/commercialhaskell/stack/releases). ## Debian Use the [generic Linux option](#linux). There is also a [Debian package](https://packages.debian.org/search?keywords=haskell-stack&searchon=names&suite=all§ion=all) for Stretch and up, but the distribution's Stack version lags behind, so running `stack upgrade --binary-only` is recommended after installing it. For older stack versions which do not support `--binary-only`, just `stack upgrade` may work too. ## CentOS / Red Hat / Amazon Linux Use the [generic Linux option](#linux). There is also an unofficial [Copr repo](https://copr.fedoraproject.org/coprs/petersen/stack/). Note that this Stack version may lag behind, so we recommend running `stack upgrade` after installing it. ## Fedora Use the [generic Linux option](#linux). There is also an unofficial [Fedora Copr repo](https://copr.fedoraproject.org/coprs/petersen/stack/) which can be enabled with: `sudo dnf copr enable petersen/stack`. Note that this Stack version may lag behind, so we recommend running `stack upgrade` after installing it. ## openSUSE / SUSE Linux Enterprise Use the [generic Linux option](#linux). There is also an unofficial SUSE package. Note that this Stack version may lag behind, so we recommend running `stack upgrade` after installing it. To install it: 1. Add the appropriate OBS repository: * openSUSE Tumbleweed all needed is in distribution * openSUSE Leap sudo zypper ar http://download.opensuse.org/repositories/devel:/languages:/haskell/openSUSE_Leap_42.1/devel:languages:haskell.repo * SUSE Linux Enterprise 12 sudo zypper ar http://download.opensuse.org/repositories/devel:/languages:/haskell/SLE_12/devel:languages:haskell.repo 2. Install: sudo zypper in stack ## Arch Linux There is an official package in the Arch community repository. So you can install it by simply doing: sudo pacman -S stack Note that this version may slightly lag behind, but it should be updated within the day. The package is also always rebuilt and updated when one of its dependencies gets an update. - [stack](https://www.archlinux.org/packages/community/x86_64/stack/) _latest stable version_ - [haskell-stack-git](https://aur.archlinux.org/packages/haskell-stack-git/) _git version_ In order to use `stack setup` with older versions of GHC or on a 32-bit system, you may need the [ncurses5-compat-libs](https://aur.archlinux.org/packages/ncurses5-compat-libs/) AUR package installed. If this package is not installed, Stack may not be able to install older (< 7.10.3) or 32-bit GHC versions. If you use the [ArchHaskell repository](https://wiki.archlinux.org/index.php/ArchHaskell), you can also get the `haskell-stack-tool` package from there. ## NixOS Users who follow the `nixos-unstable` channel or the Nixpkgs `master` branch can install the latest `stack` release into their profile by running: nix-env -f "" -iA stack Alternatively, the package can be built from source as follows. 1. Clone the git repo: git clone https://github.com/commercialhaskell/stack.git 2. Create a `shell.nix` file: cabal2nix --shell ./. --no-check --no-haddock > shell.nix Note that the tests fail on NixOS, so disable them with `--no-check`. Also, haddock currently doesn't work for stack, so `--no-haddock` disables it. 3. Install stack to your user profile: nix-env -i -f shell.nix For more information on using Stack together with Nix, please see [the NixOS manual section on Stack](http://nixos.org/nixpkgs/manual/#how-to-build-a-haskell-project-using-stack). ## Linux (generic) ### Installer script Run: curl -sSL https://get.haskellstack.org/ | sh or: wget -qO- https://get.haskellstack.org/ | sh ### Manual download * Download the latest release: * [Linux 64-bit, standard](https://get.haskellstack.org/stable/linux-x86_64.tar.gz) * [Linux 64-bit, libgmp4](https://get.haskellstack.org/stable/linux-x86_64-gmp4.tar.gz) (if you are on an older 64-bit distribution that only includes libgmp4 (libgmp.so.3), such as CentOS/RHEL/Amazon Linux 6.) * [Linux 32-bit, standard](https://get.haskellstack.org/stable/linux-i386.tar.gz) * [Linux 32-bit, libgmp4](https://get.haskellstack.org/stable/linux-i386-gmp4.tar.gz) (if you are on an older 32-bit distribution that only includes libgmp4 (libgmp.so.3), such as CentOS/RHEL/Amazon Linux 6.) * [Linux ARMv7](https://get.haskellstack.org/stable/linux-arm.tar.gz) * [Linux AArch64](https://get.haskellstack.org/stable/linux-aarch64.tar.gz) * Extract the archive and place `stack` somewhere on your `$PATH` (see [Path section below](#path)) * Ensure you have required system dependencies installed. These include GCC, GNU make, xz, perl, libgmp, libffi, and zlib. We also recommend Git and GPG. To install these using your package manager: * Debian / Ubuntu: `sudo apt-get install g++ gcc libc6-dev libffi-dev libgmp-dev make xz-utils zlib1g-dev git gnupg` * Fedora / CentOS: `sudo dnf install perl make automake gcc gmp-devel libffi zlib xz tar git gnupg` (use `yum` instead of `dnf` on CentOS and Fedora <= 21) * Fedora 24: In order to use `stack setup` on a 32-bit system, you may need to run `sudo dnf install ncurses-compat-libs`. If this package is not installed, Stack may not be able to install 32-bit GHC versions. Also `sudo dnf install ncurses-compat-libs` if you nee * Arch Linux: `sudo pacman -S make gcc ncurses git gnupg xz zlib gmp libffi zlib` * In order to use `stack setup` with older versions of GHC or on a 32-bit system, you may need the [ncurses5-compat-libs](https://aur.archlinux.org/packages/ncurses5-compat-libs/) AUR package installed. If this package is not installed, Stack may not be able to install older (< 7.10.3) or 32-bit GHC versions. * Gentoo users, make sure to have the `ncurses` package with `USE=tinfo` (without it, stack will not be able to install GHC). * Now you can run `stack` from the terminal. ## FreeBSD (only 64-bit currently available, tested on FreeBSD 10.3-RELEASE) ### Installer script Run: curl -sSL https://get.haskellstack.org/ | sh ### Manual download * Install required dependencies: pkg install devel/gmake perl5 lang/gcc misc/compat8x misc/compat9x converters/libiconv ca_root_nss * Download the latest release: * [FreeBSD 64-bit](https://get.haskellstack.org/stable/freebsd-x86_64.tar.gz) * Extract the archive and place `stack` somewhere on your `$PATH` (see [Path section below](#path)) * Now you can run `stack` from the terminal. ## Path You can install stack by copying it anywhere on your PATH environment variable. We recommend installing in the same directory where stack itself will install executables (that way stack is able to upgrade itself!). On Windows, that directory is `%APPDATA%\local\bin`, e.g. "c:\Users\Michael\AppData\Roaming\local\bin". For other systems, use `$HOME/.local/bin`. If you don't have that directory in your PATH, you may need to update your PATH (such as by editing .bashrc). If you're curious about the choice of these paths, see [issue #153](https://github.com/commercialhaskell/stack/issues/153) ## Shell auto-completion To get tab-completion of commands on bash, just run the following (or add it to `.bashrc`): eval "$(stack --bash-completion-script stack)" For more information and other shells, see [the shell auto-completion page](shell_autocompletion.md) ## China-based users If you're attempting to install stack from within China: * As of 2018-10-24, the download link has limited connectivity from within mainland China. If this is the case, please proceed by manually downloading (ideally via a VPN) and installing stack per the instructions found on this page pertinent to your OS. * After install, your ~/.stack/config.yaml will need to be configured before stack can download large files consistently from within China (without reliance on a VPN). Please add the following to the bottom of the ~/.stack/config.yaml file (for Windows: use the %STACK_ROOT%\config.yaml): ``` ###ADD THIS IF YOU LIVE IN CHINA setup-info: "http://mirrors.tuna.tsinghua.edu.cn/stackage/stack-setup.yaml" urls: latest-snapshot: http://mirrors.tuna.tsinghua.edu.cn/stackage/snapshots.json lts-build-plans: http://mirrors.tuna.tsinghua.edu.cn/stackage/lts-haskell/ nightly-build-plans: http://mirrors.tuna.tsinghua.edu.cn/stackage/stackage-nightly/ package-indices: - name: Tsinghua download-prefix: http://mirrors.tuna.tsinghua.edu.cn/hackage/package/ http: http://mirrors.tuna.tsinghua.edu.cn/hackage/00-index.tar.gz ``` ## Using an http proxy To use `stack` behind a http proxy with ip address *IP* and port *PORT*, first set up an environment variable `http_proxy` and then run the stack command. _e.g._ ``` $ export http_proxy=IP:PORT $ stack install ``` Note that on most operating systems, it is not mandatory for programs to follow the "system-wide" http proxy. Some programs, such as browsers, do honor this "system-wide" http proxy setting, while other programs, including bash, do not. That means configuring "http proxy setting" in your Control Panel (Windows) or System Preferences (Mac) would not result in `stack` traffic going through the proxy. ## Upgrade There are essentially four different approaches to upgrade: * The `stack` tool itself ships with an `upgrade` command, which download a `stack` binary or build it from source and install it to the default install path (e.g. `~/.local/bin` or `%APPDATA%\local\bin`; see the [Path](#Path) section above). You can use `stack upgrade` to get the latest official release, and `stack upgrade --git` to install from Git and live on the bleeding edge. Make sure the default install directory is on your `PATH` and takes precedence over the system installed `stack`, or copy `stack` from that directory to the system location afterward. For more information, see [this discussion](https://github.com/commercialhaskell/stack/issues/237#issuecomment-126793301). * If you're using a package manager and are happy with sticking with the officially released binaries from the distribution (which may the lag behind latest version of Stack significantly), simply follow your normal package manager strategies for upgrading (e.g. `apt-get update && apt-get upgrade`). * The get.haskellstack.org script supports the `-f` argument to over-write the current stack executable. For example: curl -sSL https://get.haskellstack.org/ | sh -s - -f or: wget -qO- https://get.haskellstack.org/ | sh -s - -f * Manually follow the steps above to download the newest binaries from the release page and replace the old binary. stack-1.9.3.1/doc/nix_integration.md0000644000000000000000000002370413455666157015476 0ustar0000000000000000
# Nix integration (since 0.1.10.0) When using the Nix integration, Haskell dependencies are handled as usual: They are downloaded from Stackage and built locally by Stack. Nix is used by Stack to provide the _non-Haskell_ dependencies needed by these Haskell packages. `stack` can automatically create a build environment (the equivalent of a "container" in Docker parlance) using `nix-shell`, provided Nix is already installed on your system. To do so, please visit the [Nix download page](http://nixos.org/nix/download.html). There are two ways to create a build environment: - providing a list of packages (by "attribute name") from [Nixpkgs](http://nixos.org/nixos/packages.html), or - providing a custom `shell.nix` file containing a Nix expression that determines a *derivation*, i.e. a specification of what resources are available inside the shell. The second requires writing code in Nix's custom language. So use this option only if you already know Nix and have special requirements, such as using custom Nix packages that override the standard ones or using system libraries with special requirements. ### Checking Nix installation Follow the instructions on the [Nix download page](http://nixos.org/nix/download.html) to install Nix. After doing so, when opening a terminal, the nix commands (`nix-build`, `nix-shell`, etc) should be available. If they are not, it should be because the file located at `$HOME/.nix-profile/etc/profile.d/nix.sh` is not sourced by your shell. You should either run `source ~/.nix-profile/etc/profile.d/nix.sh` manually every time you open a terminal and need Nix or add this command to your `~/.bashrc` or `~/.bash_profile`. ### Additions to your `stack.yaml` Add a section to your `stack.yaml` as follows: ```yaml nix: enable: true packages: [glpk, pcre] ``` This will instruct `stack` to build inside a local build environment that will have the `glpk` and `pcre` libraries installed and available. Further, the build environment will implicitly also include a version of GHC matching the configured resolver. Enabling Nix support means packages will always be built using a GHC available inside the shell, rather than your globally installed one if any. Note that in this mode `stack` can use only GHC versions that have already been mirrored into the Nix package repository. The [Nixpkgs master branch](https://github.com/NixOS/nixpkgs/tree/master/pkgs/development/haskell-modules) usually picks up new versions quickly, but it takes two or three days before those updates arrive in the `unstable` channel. Release channels, like `nixos-15.09`, receive those updates only occasionally -- say, every two or three months --, so you should not expect them to have the latest compiler available. Fresh NixOS installs use a release version by default. To know for sure whether a given compiler is available on your system, you can use the command ```sh $ nix-env -f "" -qaP -A haskell.compiler.ghc801 haskell.compiler.ghc801 ghc-8.0.1 ``` to check whether it's available. If Nix doesn't know that resolver yet, then you'll see the following error message instead: ```sh $ nix-env -f "" -qaP -A haskell.compiler.ghc999 error: attribute ‘ghc999’ in selection path ‘haskell.compiler.ghc999’ not found ``` You can list all known Haskell compilers in Nix with the following: ```sh $ nix-instantiate --eval -E "with import {}; lib.attrNames haskell.compiler" ``` Alternatively, install `nix-repl`, a convenient tool to explore nixpkgs: ```sh $ nix-env -i nix-repl $ nix-repl ``` In the REPL, load nixpkgs and get the same information through autocomplete: ```sh nix-repl> :l nix-repl> haskell.compiler.ghc ``` You can type and evaluate any nix expression in the nix-repl, such as the one we gave to `nix-instantiate` earlier. **Note:** currently, stack only discovers dynamic and static libraries in the `lib/` folder of any nix package, and likewise header files in the `include/` folder. If you're dealing with a package that doesn't follow this standard layout, you'll have to deal with that using a custom shell file (see below). ### Use stack as normal With Nix enabled, `stack build` and `stack exec` will automatically launch themselves in a local build environment (using `nix-shell` behind the scenes). `stack setup` will start a nix-shell, so it will gather all the required packages, but given nix handles GHC installation, instead of stack, this will happen when running `stack build` if no setup has been performed before. Therefore it is not longer necessary to run `stack setup` unless you want to cache a GHC installation before running the build. If `enable:` is omitted or set to `false`, you can still build in a nix-shell by passing the `--nix` flag to stack, for instance `stack --nix build`. Passing any `--nix*` option to the command line will do the same. **Known limitation on macOS:** currently, `stack --nix ghci` fails on macOS, due to a bug in GHCi when working with external shared libraries. ### The Nix shell By default, stack will run the build in a *pure* Nix build environment (or *shell*), which means two important things: - basically **no environment variable will be forwarded** from your user session to the nix-shell (variables like `HTTP_PROXY` or `PATH` notably will not be available), - the build should fail if you haven't specified all the dependencies in the `packages:` section of the `stack.yaml` file, even if these dependencies are installed elsewhere on your system. This behaviour enforces a complete description of the build environment to facilitate reproducibility. To override this behaviour, add `pure: false` to your `stack.yaml` or pass the `--no-nix-pure` option to the command line. **Note:** On macOS shells are non-pure by default currently. This is due soon to be resolved locale issues. So on macOS you'll need to be a bit more careful to check that you really have listed all dependencies. ### Package sources By default, `nix-shell` will look for the nixpkgs package set located by your `NIX_PATH` environment variable. You can override this by passing `--nix-path="nixpkgs=/my/own/nixpkgs/clone"` to ask Nix to use your own local checkout of the nixpkgs repository. You could in this way use a bleeding edge nixpkgs, cloned from the [nixpkgs](http://www.github.com/NixOS/nixpkgs) `master` branch, or edit the nix descriptions of some packages. Setting ```yml nix: path: [nixpkgs=/my/own/nixpkgs/clone] ``` in your `stack.yaml` will do the same. ## Command-line options The configuration present in your `stack.yaml` can be overridden on the command-line. See `stack --nix-help` for a list of all Nix options. ## Configuration `stack.yaml` contains a `nix:` section with Nix settings. Without this section, Nix will not be used. Here is a commented configuration file, showing the default values: ```yaml nix: # false by default. Must be present and set to `true` to enable Nix, except on # NixOS where it is enabled by default (see #3938). You can set set it in your # `$HOME/.stack/config.yaml` to enable Nix for all your projects without having # to repeat it # enable: true # true by default. Tells Nix whether to run in a pure shell or not. pure: true # Empty by default. The list of packages you want to be # available in the nix-shell at build time (with `stack # build`) and run time (with `stack exec`). packages: [] # Unset by default. You cannot set this option if `packages:` # is already present and not empty. shell-file: shell.nix # A list of strings, empty by default. Additional options that # will be passed verbatim to the `nix-shell` command. nix-shell-options: [] # A list of strings, empty by default, such as # `[nixpkgs=/my/local/nixpkgs/clone]` that will be used to override # NIX_PATH. path: [] # false by default. Whether to add your nix dependencies as nix garbage # collection roots. This way, calling nix-collect-garbage will not remove # those packages from the nix store, saving you some time when running # stack build again with nix support activated. # This creates a `nix-gc-symlinks` directory in the project `.stack-work`. # To revert that, just delete this `nix-gc-symlinks` directory. add-gc-roots: false ``` ## Using a custom shell.nix file Nix is also a programming language, and as specified [here](#nix-integration) if you know it you can provide to the shell a fully customized derivation as an environment to use. Here is the equivalent of the configuration used in [this section](#additions-to-your-stackyaml), but with an explicit `shell.nix` file (make sure you're using a nixpkgs version later than 2015-03-05): ```nix {ghc}: with (import {}); haskell.lib.buildStackProject { inherit ghc; name = "myEnv"; buildInputs = [ glpk pcre ]; } ``` Defining manually a `shell.nix` file gives you the possibility to override some Nix derivations ("packages"), for instance to change some build options of the libraries you use, or to set additional environment variables. See the [Nix manual][nix-manual-exprs] for more. The `buildStackProject` utility function is documented in the [Nixpkgs manual][nixpkgs-manual-haskell]. In such case, stack expect this file to define a function of exactly one argument that should be called `ghc` (as arguments within a set are non-positional), which you should give to `buildStackProject`. This is the ghc from the resolver you set in the `stack.yaml`. And now for the `stack.yaml` file: ```yaml nix: enable: true shell-file: shell.nix ``` The `stack build` command will behave exactly the same as above. Note that specifying both `packages:` and a `shell-file:` results in an error. (Comment one out before adding the other.) [nix-manual-exprs]: http://nixos.org/nix/manual/#chap-writing-nix-expressions [nixpkgs-manual-haskell]: https://nixos.org/nixpkgs/manual/#users-guide-to-the-haskell-infrastructure stack-1.9.3.1/doc/nonstandard_project_init.md0000644000000000000000000001174013455666157017356 0ustar0000000000000000
# Non-standard project initialization ## Introduction The purpose of this page is to collect information about issues that arise when users either have an existing cabal project or another nonstandard setup such as a private hackage database. ## Using a Cabal File New users may be confused by the fact that you must add dependencies to the package's cabal file, even in the case when you have already listed the package in the `stack.yaml`. In most cases, dependencies for your package that are in the Stackage snapshot need *only* be added to the cabal file. stack makes heavy use of Cabal the library under the hood. In general, your stack packages should also end up being valid cabal-install packages. ### Issues Referenced - https://github.com/commercialhaskell/stack/issues/105 ## Passing Flags to Cabal Any build command, `bench`, `install`, `haddock`, `test`, etc. takes a `--flag` option which passes flags to cabal. Another way to do this is using the flags field in a `stack.yaml`, with the option to specify flags on a per package basis. As an example, in a `stack.yaml` for multi-package project with packages `foo`, `bar`, `baz`: ``` flags: foo: release: true bar: default: true baz: manual: true ``` It is also possible to pass the same flag to multiple packages, i.e. `stack build --flag *:necessary` Currently one needs to list all of your modules that interpret flags in the `other-modules` section of a cabal file. `cabal-install` has a different behavior currently and doesn't require that the modules be listed. This may change in a future release. ### Issues Referenced - https://github.com/commercialhaskell/stack/issues/191 - https://github.com/commercialhaskell/stack/issues/417 - https://github.com/commercialhaskell/stack/issues/335 - https://github.com/commercialhaskell/stack/issues/301 - https://github.com/commercialhaskell/stack/issues/365 - https://github.com/commercialhaskell/stack/issues/105 ## Selecting a Resolver `stack init` or `stack new` will try to default to the current Haskell LTS present on `https://www.stackage.org/snapshots` if no snapshot has been previously used locally, and to the latest LTS snapshot locally used for a build otherwise. Using an incorrect resolver can cause a build to fail if the version of GHC it requires is not present. In order to override the resolver entry at project initialization one can pass `--prefer-lts` or `--prefer-nightly`. These options will choose the latest LTS or nightly versions locally used. Alternatively the `--resolver` option can be used with the name of any snapshots on Stackage, or with `lts` or `nightly` to select the latest versions, disregarding previously used ones. This is not the default so as to avoid unnecessary recompilation time. :TODO: Document `--solver` ### Issues Referenced - https://github.com/commercialhaskell/stack/issues/468 - https://github.com/commercialhaskell/stack/issues/464 ## Using git Repositories stack has support for packages that reside in remote git locations. Example: ``` packages: - '.' - location: git: https://github.com/kolmodin/binary commit: 8debedd3fcb6525ac0d7de2dd49217dce2abc0d9 ``` ### Issues Referenced - https://github.com/commercialhaskell/stack/issues/254 - https://github.com/commercialhaskell/stack/issues/199 ## Private Hackage Working with a private Hackage is currently supported in certain situations. There exist special entries in `stack.yaml` that may help you. In a `stack.yaml` file, it is possible to add lines for packages in your database referencing the sdist locations via an `http` entry, or to use a `Hackage` entry. The recommended stack workflow is to use git submodules instead of a private Hackage. Either by using git submodules and listing the directories in the packages section of `stack.yaml`, or by adding the private dependencies as git URIs with a commit SHA to the `stack.yaml`. This has the large benefit of eliminating the need to manage a Hackage database and pointless version bumps. For further information see [YAML configuration](yaml_configuration.md) ### Issues Referenced - https://github.com/commercialhaskell/stack/issues/445 - https://github.com/commercialhaskell/stack/issues/565 ## Custom Snapshots Currently WIP? ### Issues Referenced - https://github.com/commercialhaskell/stack/issues/111 - https://github.com/commercialhaskell/stack/issues/253 - https://github.com/commercialhaskell/stack/issues/137 ## Intra-package Targets stack supports intra-package targets, similar to `cabal build COMPONENTS` for situations when you don't want to build every target inside your package. Example: ``` stack build stack:lib:stack stack test stack:test:stack-integration-test ``` Note: this does require prefixing the component name with the package name. ### Issues referenced - https://github.com/commercialhaskell/stack/issues/201 stack-1.9.3.1/doc/README.md0000644000000000000000000001561313455666157013232 0ustar0000000000000000
# The Haskell Tool Stack Stack is a cross-platform program for developing Haskell projects. It is aimed at Haskellers both new and experienced. It features: * Installing GHC automatically, in an isolated location. * Installing packages needed for your project. * Building your project. * Testing your project. * Benchmarking your project. #### How to install For many Un*x operating systems, all you need to do is run: curl -sSL https://get.haskellstack.org/ | sh or: wget -qO- https://get.haskellstack.org/ | sh On Windows, you can download and install the [Windows 64-bit Installer](https://get.haskellstack.org/stable/windows-x86_64-installer.exe). For detailed instructions and downloads, including many additional operating systems, check out the [install and upgrade page](install_and_upgrade.md). #### Quick Start Guide First you need to [install it (see previous section)](#how-to-install). ##### Start your new project: ```bash stack new my-project cd my-project stack setup stack build stack exec my-project-exe ``` - The `stack new` command will create a new directory containing all the needed files to start a project correctly. - The `stack setup` will download the compiler if necessary in an isolated location (default `~/.stack`) that won't interfere with any system-level installations. (For information on installation paths, please use the `stack path` command.). - The `stack build` command will build the minimal project. - `stack exec my-project-exe` will execute the command. - If you just want to install an executable using stack, then all you have to do is `stack install `. If you want to launch a REPL: ```bash stack ghci ``` Run `stack` for a complete list of commands. ##### Workflow The `stack new` command should have created the following files: ``` . ├── LICENSE ├── Setup.hs ├── app │   └── Main.hs ├── my-project.cabal ├── src │   └── Lib.hs ├── stack.yaml └── test └── Spec.hs 3 directories, 7 files ``` So to manage your library: 1. Edit files in the `src/` directory. The `app` directory should preferably contain only files related to executables. 2. If you need to include another library (for example the package [`text`](https://hackage.haskell.org/package/text)): - Add the package `text` to the file `package.yaml` in the section `dependencies: ...`. - Run `stack build` another time. - `stack build` will update my-project.cabal for you. If desired you can update the .cabal file manually and stack will use .cabal instead of package.yaml. 3. If you get an error that tells you your package isn't in the LTS. Just try to add a new version in the `stack.yaml` file in the `extra-deps` section. That was a really fast introduction on how to start to code in Haskell using `stack`. If you want to go further, we highly recommend you to read the [`stack` guide](GUIDE.md). #### How to contribute This assumes that you have already installed a version of stack, and have `git` installed. 1. Clone `stack` from git with `git clone https://github.com/commercialhaskell/stack.git`. 2. Enter into the stack folder with `cd stack`. 3. Build `stack` using a pre-existing `stack` install with `stack setup && stack build`. 4. Once `stack` finishes building, check the stack version with `stack exec stack -- --version`. Make sure the version is the latest. 5. Look for issues tagged with [newcomer friendly](https://github.com/commercialhaskell/stack/issues?q=is%3Aopen+is%3Aissue+label%3a%22newcomer+friendly%22) and [awaiting pull request](https://github.com/commercialhaskell/stack/issues?q=is%3Aopen+is%3Aissue+label%3A%22awaiting+pull+request%22) labels. Build from source as a one-liner: ```bash git clone https://github.com/commercialhaskell/stack.git && \ cd stack && \ stack setup && \ stack build ``` If you need to check your changes quickly run: ```bash stack ghci λ: :main --stack-root /path/to/root/ --stack-yaml /path/to/stack.yaml COMMAND ``` This allows you to set a special stack root (instead of `~/.stack/`) and to target your commands at a particular `stack.yaml` instead of the one found in the current directory. #### Complete guide to stack This repository also contains a complete [user guide to using stack](GUIDE.md), covering all of the most common use cases. #### Questions, Feedback, Discussion * For frequently asked questions about detailed or specific use-cases, please see [the FAQ](faq.md). * For general questions, comments, feedback and support, please write to [the stack mailing list](https://groups.google.com/d/forum/haskell-stack). * For bugs, issues, or requests, please [open an issue](https://github.com/commercialhaskell/stack/issues/new). * When using Stack Overflow, please use [the haskell-stack tag](http://stackoverflow.com/questions/tagged/haskell-stack). #### Why Stack? Stack is a build tool for Haskell designed to answer the needs of Haskell users new and experienced alike. It has a strong focus on reproducible build plans, multi-package projects, and a consistent, easy-to-learn interface, while providing the customizability and power experienced developers need. As a build tool, Stack does not stand alone. It is built on the great work provided by: * The __Glasgow Haskell Compiler__ (GHC), the premier Haskell compiler. Stack will manage your GHC installations and automatically select the appropriate compiler version for your project. * The __Cabal build system__, a specification for defining Haskell packages, together with a library for performing builds. * The __Hackage package repository__, providing more than ten thousand open source libraries and applications to help you get your work done. * The __Stackage package collection__, a curated set of packages from Hackage which are regularly tested for compatibility. Stack defaults to using Stackage package sets to avoid dependency problems. Stack is provided by a team of volunteers and companies under the auspices of the [Commercial Haskell](http://commercialhaskell.com/) group. The project was spearheaded by [FP Complete](https://www.fpcomplete.com/) to answer the needs of commercial Haskell users, and has since become a thriving open source project meeting the needs of Haskell users of all stripes. If you'd like to get involved with Stack, check out the [newcomer friendly](https://github.com/commercialhaskell/stack/issues?q=is%3Aopen+is%3Aissue+label%3a%22newcomer+friendly%22) label on the Github issue tracker. #### How to uninstall Removing ``~/.stack`` and ``/usr/local/bin/stack`` should be sufficient. You may want to delete ``.stack-work`` folders in any Haskell projects that you have built. stack-1.9.3.1/doc/shell_autocompletion.md0000644000000000000000000000345013455666157016522 0ustar0000000000000000
# Shell Auto-completion Note: if you installed a package for you Linux distribution, the bash completion file was automatically installed (you may need the `bash-completion` package to have it take effect). The following adds support for shell tab completion for standard Stack arguments, although completion for filenames and executables etc. within stack is still lacking (see [issue 823](https://github.com/commercialhaskell/stack/issues/832)). ## for bash users you need to run following command ``` eval "$(stack --bash-completion-script stack)" ``` You can also add it to your `.bashrc` file if you want. ## for ZSH users documentation says: > Zsh can handle bash completions functions. The latest development version of > zsh has a function bashcompinit, that when run will allow zsh to read bash > completion specifications and functions. This is documented in the zshcompsys > man page. To use it all **you need to do is run bashcompinit at any time > after compinit**. It will define complete and compgen functions corresponding > to the bash builtins. You must so: 1. launch compinint 2. launch bashcompinit 3. eval stack bash completion script ```shell autoload -U +X compinit && compinit autoload -U +X bashcompinit && bashcompinit eval "$(stack --bash-completion-script stack)" ``` :information_source: If you already have quite a large zshrc, or if you use oh-my-zsh, **compinit** will probably already be loaded. If you have a blank zsh config, all of the 3 lines above are necessary. :gem: tip: instead of running those 3 lines from your shell every time you want to use stack, you can add those 3 lines in your $HOME/.zshrc file stack-1.9.3.1/doc/SIGNING_KEY.md0000644000000000000000000000360613455666157014102 0ustar0000000000000000
# Signing key Releases are signed with this key: ``` -----BEGIN PGP PUBLIC KEY BLOCK----- Version: GnuPG v1 mQENBFVs+cMBCAC5IsLWTikd1V70Ur1FPJMn14Sc/C2fbXc0zRcPuWX+JaXgrIJQ 74A3UGBpa07wJDZiQLLz4AasDQj++9gXdiM9MlK/xWt8BQpgQqSMgkktFVajSWX2 rSXPjqLtsl5dLsc8ziBkd/AARXoeITmXX+n6oRTy6QfdMv2Tacnq7r9M9J6bAz6/ 7UsKkyZVwsbUPea4SuD/s7jkXAuly15APaYDmF5mMlpoRWp442lJFpA0h52mREX1 s5FDbuKRQW7OpZdLcmOgoknJBDSpKHuHEoUhdG7Y3WDUGYFZcTtta1qSVHrm3nYa 7q5yOzPW4/VpftkBs1KzIxx0nQ5INT5W5+oTABEBAAG0H0ZQQ29tcGxldGUgPGRl dkBmcGNvbXBsZXRlLmNvbT6JATcEEwEKACEFAlVs+cMCGwMFCwkIBwMFFQoJCAsF FgMCAQACHgECF4AACgkQV1FZaJvvtEIP8gf/S/k4C3lp/BFb0K9DHHSt6EaGQPwy g+O8d+JvL7ghkvMjlQ+UxDw+LfRKANTpl8a4vHtEQLHEy1tPJfrnMA8DNci8HLVx rK3lIqMfv5t85VST9rz3X8huSw7qwFyxsmIqFtJC/BBQfsOXC+Q5Z2nbResXHMeA 5ZvDopZnqKPdmMOngabPGZd89hOKn6r8k7+yvZ/mXmrGOB8q5ZGbOXUbCshst7lc yZWmoK3VJdErQjGHCdF4MC9KFBQsYYUy9b1q0OUv9QLtq/TeKxfpvYk9zMWAoafk M8QBE/qqOpqkBRoKbQHCDQgx7AXJMKnOA0jPx1At57hWl7PuEH4rK38UtLkBDQRV bPnDAQgAx1+4ENyaMk8XznQQ4l+nl8qw4UedZhnR5Xxr6z2kcMO/0VdwmIDCpxaM spurOF+yExfY/Chbex7fThWTwVgfsItUc/QLLv9jkvpveMUDuPyh/4QrAQBYoW09 jMJcOTFQU+f4CtKaN/1PNoTSU2YkVpbhvtV3Jn2LPFjUSPb7z2NZ9NKe10M0/yN+ l0CuPlqu6GZR5L3pA5i8PZ0Nh47j0Ux5KIjrjCGne4p+J8qqeRhUf04yHAYfDLgE aLAG4v4pYbb1jNPUm1Kbk0lo2c3dxx0IU201uAQ6LNLdF/WW/ZF7w3iHn7kbbzXO jhbq2rvZEn3K9xDr7homVnnj21/LSQARAQABiQEfBBgBCgAJBQJVbPnDAhsMAAoJ EFdRWWib77RC3ukH/R9jQ4q6LpXynQPJJ9QKwstglKfoKNpGeAYVTEn0e7NB0HV5 BC+Da5SzBowboxC2YCD1wTAjBjLLQfAYNyR+tHpJBaBmruafj87nBCDhSWwWDXwx OUDpNOwKUkrwZDRlM7n4byoMRl7Vh/7CXxaTqkyao1c5v3mHh/DremiTvOJ4OXgJ 77NHaPXezHkCFZC8/sX6aY0DJxF+LIE84CoLI1LYBatH+NKxoICKA+yeF3RIVw0/ F3mtEFEtmJ6ljSks5tECxfJFvQlkpILBbGvHfuljKMeaj+iN+bsHmV4em/ELB1ku N9Obs/bFDBMmQklIdLP7dOunDjY4FwwcFcXdNyg= =YUsC -----END PGP PUBLIC KEY BLOCK----- ``` stack-1.9.3.1/doc/stack_yaml_vs_cabal_package_file.md0000644000000000000000000001464513455666157020734 0ustar0000000000000000
# stack.yaml vs cabal package file Due to their apparent overlap, the purpose of the following three files can be unclear: * `stack.yaml` * A cabal package file, e.g. `my-package.cabal` * `package.yaml` The last two are easy to explain: `package.yaml` is a file format supported by [hpack](https://github.com/sol/hpack#readme). It adds some niceties on top of cabal. For example, hpack has YAML syntax support and will automatically generate of `exposed-modules` lists. However, it's just a frontend to cabal package files. So for this document, we're instead going to focus on the first two and try to answer: _What's the difference between a `stack.yaml` file and a cabal package file?_ ## Package versus project Cabal is a build system, which is used by Stack. Cabal defines the concept of a _package_. A package has: * A name and version * 0 or 1 libraries * 0 or more executables * A cabal file (or, as mentioned above, an hpack `package.yaml` that generates a cabal file) * And a bunch more The second to last bullet bears repeating: there's a 1-to-1 correspondence between packages and cabal files. Stack is a build tool that works on top of the Cabal build system, and defines a new concept called a _project_. A project has: * A _resolver_, which tells it about a snapshot (more on this later) * Extra dependencies on top of the snapshot * 0 or more local Cabal packages * Flag and GHC options configurations * And a bunch more Stack configuration A source of confusion is that, often, you'll have a project that defines exactly one package you're working on, and in that situation it's unclear why, for example, you need to specify an extra depedency in both your `stack.yaml` _and_ cabal file. To explain, let's take a quick detour to talk about snapshots and how Stack resolves dependencies. ## Resolvers and snapshots Stack follows a rule that says, for any projects, there is precisely 1 version of each package available. Obviously there are _many_ versions of many different packages available in the world. But when resolving a `stack.yaml` file, Stack requires that you have chosen a specific version for each package available. The most common means by which this set of packages is defined is via a Stackage Snapshot. For example, if you go to the page , you will see a list of 2,666 packages at specific version numbers. When you then specify `resolver: lts-10.2`, you're telling Stack to use those package versions in resolving dependencies down to concrete version numbers. Sometimes a snapshot doesn't have all of the packages you want. Or you want a different version. Or you want to work on a local modification of a package. In all of those cases, you can add more configuration data to your `stack.yaml` to override the values it received from your `resolver` setting. At the end of the day, each of your projects will end up with some way of resolving a package name into a concrete version number. ## Why specify deps twice? When you add something like this to your `stack.yaml` file: ```yaml extra-deps: - acme-missiles-0.3 ``` What you're saying to Stack is: if at any point you find that you need to build the `acme-missiles` package, please use version `0.3`. You are _not_ saying "please build `acme-missiles` now." You are also not saying "my package depends on `acme-missiles`." You are simply making it available should the need arise. When you add `build-depends: acme-missiles` to your cabal file or `dependencies: [acme-missiles]` to your `package.yaml` file, you're saying "this package requires that `acme-missiles` be available." Since `acme-missiles` doesn't appear in your snapshot, without also modifying your `stack.yaml` to mention it via `extra-deps`, Stack will complain about the dependency being unavailable. You may challenge: but why go through all of that annoyance? Stack knows what package I want, why not just go grab it? The answer is that, if Stack just grabbed `acme-missiles` for you without it being specified in the `stack.yaml` somehow, you'd lose reproducibility. How would Stack know which version to use? It may elect to use the newest version, but if a new version is available in the future, will it automatically switch to that? Stack's baseline philosophy is that build plans are always reproducible\*. The purpose of the `stack.yaml` file is to define an immutable set of packages. No matter when in time you use it, and no matter how many new release happen in the interim, the build plan generated should be the same. \* There's at least one hole in this theory today, which is Hackage revisions. When you specify `extra-deps: [acme-missiles-0.3]`, it doesnt' specify which revision of the cabal file to use, and Stack will just choose the latest. Stack version 1.6 added the ability to specify exact revisions of cabal files, but this isn't enforced as a requirement as it's so different from the way most people work with packages. And now, how about the other side: why doesn't Stack automatically add `acme-missiles` to `build-depends` in your cabal file if you add it as an extra-dep? There are a surprising number reasons actually: * The cabal spec doesn't support anything like that * There can be multiple packages in a project, and how do we know which package actually needs the dependency? * There can be multiple components (libraries, executable, etc) in a package, and how do we know which of those actually needs the dependency? * The dependency may only be conditionally needed, based on flags, OS, or architecture. As an extreme example, we wouldn't want a Linux-only package to be force-built on Windows. While for simple use cases it seems like automatically adding dependencies from the cabal file to the `stack.yaml` file or vice-versa would be a good thing, it breaks down immediately for any semi-difficult case. Therefore, Stack requires you to add it to both places. And a final note, in case it wasn't clear. The example I gave above used `acme-missiles`, which is not in Stackage snapshots. If, however, you want to depend on a package already present in the snapshot you've selected, there's no need to add it explicitly to your `stack.yaml` file: it's already there implicitly via the `resolver` setting. This is what you do the majority of the time, such as when you add `vector` or `mtl` as a `build-depends` value. stack-1.9.3.1/doc/travis_ci.md0000644000000000000000000001512513455666157014256 0ustar0000000000000000
# Travis CI This page documents how to use Stack on [Travis CI](https://travis-ci.org/). We assume you have basic familiarity with Travis. We provide two fully baked example files ready to be used on your projects: * [The simple Travis configuration](https://raw.githubusercontent.com/commercialhaskell/stack/stable/doc/travis-simple.yml) is intended for applications that do not require multiple GHC support or cross-platform support. It builds and tests your project with just the settings present in your `stack.yaml` file. * [The complex Travis configuration](https://raw.githubusercontent.com/commercialhaskell/stack/stable/doc/travis-complex.yml) is intended for projects that need to support multiple GHC versions and multiple OSes, such as open source libraries to be released to Hackage. It tests against cabal-install, as well as Stack on Linux and macOS. The configuration is significantly more involved to allow for all of this branching behavior. __NOTE__: It is likely going to be necessary to modify this configuration to match the needs of your project, such as tweaking the build matrix to alter which GHC versions you test against, or to specify GHC-version-specific `stack.yaml` files if necessary. Don't be surprised if it doesn't work the first time around. See the multiple GHC section below for more information. Each of these configurations is ready to be used immediately, just copy-paste the content into the `.travis.yml` file in the root or your repo, enable Travis on the repo, and you're good to go. You may also be interested in using AppVeyor, which supports Windows builds, for more cross-platform testing. There's a [short blog post available on how to do this](http://www.snoyman.com/blog/2016/08/appveyor-haskell-windows-ci), or just copy in [the appveyor.yml file](https://raw.githubusercontent.com/commercialhaskell/stack/stable/doc/appveyor.yml) The rest of this document explains the details of common Travis configurations for those of you who want to tweak the above configuration files or write your own. *Note:* both Travis and Stack infrastructures are actively developed. We try to document best practices at the moment. ## Container infrastructure For Stack on Travis to be practical, we must use caching. Otherwise build times will take an incredibly long time, about 30 minutes versus 3-5. Caching is currently available only for [container-based Travis infrastructure](http://docs.travis-ci.com/user/workers/container-based-infrastructure/). Shortly we have to add ```yaml sudo: false # Caching so the next build will be fast too. cache: directories: - $HOME/.stack ``` To the `.travis.yml`. This however restricts how we can install GHC and Stack on the Travis machines. ## Installing Stack Currently there is only one reasonable way to install Stack: fetch precompiled binary from the Github. ```yaml before_install: # Download and unpack the stack executable - mkdir -p ~/.local/bin - export PATH=$HOME/.local/bin:$PATH - travis_retry curl -L https://get.haskellstack.org/stable/linux-x86_64.tar.gz | tar xz --wildcards --strip-components=1 -C ~/.local/bin '*/stack' ``` ## Installing GHC There are two ways to install GHC: - Let Stack download GHC - Install GHC using [apt plugin](http://docs.travis-ci.com/user/apt/) See the above scripts for an example of the first option (letting Stack download GHC). Here, we will explain the second option. With single GHC the situation is simple: ```yaml before_install: # Install stack as above # ... # Configure stack to use the system GHC installation - stack config set system-ghc --global true - export PATH=/opt/ghc/7.10.2/bin:$PATH addons: apt: sources: - hvr-ghc packages: - ghc-7.10.2 ``` ### Multiple GHC - parametrised builds Travis apt plugin doesn't yet support installing apt packages dynamically (https://github.com/travis-ci/travis-ci/issues/4291). That for we need to write a bit repetitive `.travis.yml`. Also for different GHC versions, you probably want to use different `stack.yaml` files. ```yaml # N.B. No top-level env: declaration! matrix: include: - env: GHCVER=7.8.4 STACK_YAML=stack.yaml addons: apt: sources: - hvr-ghc packages: - ghc-7.8.4 - env: GHCVER=7.10.1 STACK_YAML=stack-7.10.yaml addons: apt: sources: - hvr-ghc packages: - ghc-7.10.1 - env: GHCVER=head STACK_YAML=stack-head.yaml addons: apt: sources: - hvr-ghc packages: - ghc-head allow_failures: - env: GHCVER=head STACK_YAML=stack-head.yaml before_install: # ghc - export PATH=/opt/ghc/$GHCVER/bin:$PATH ``` Especially to use ghc `HEAD` you need to pass `--skip-ghc-check` option to Stack. ## Running tests After the environment setup, actual test running is simple: ```yaml script: - stack --no-terminal --skip-ghc-check test ``` In case you're wondering: we need `--no-terminal` because stack does some fancy sticky display on smart terminals to give nicer status and progress messages, and the terminal detection is broken on Travis. ## Other details Some Stack commands will run for long time (when cache is cold) without producing any output. To avoid timeouts, use the built in [travis_wait](https://docs.travis-ci.com/user/common-build-problems/#Build-times-out-because-no-output-was-received). ```yaml install: - travis_wait stack --no-terminal --skip-ghc-check setup - travis_wait stack --no-terminal --skip-ghc-check test --only-snapshot ``` ## Examples - [futurice/fum2github](https://github.com/futurice/fum2github/blob/master/.travis.yml) - [haskell-distributed/cloud-haskell](https://github.com/haskell-distributed/cloud-haskell/blob/master/.travis.yml) - [simonmichael/hledger](https://github.com/simonmichael/hledger/blob/master/.travis.yml) - [fpco/wai-middleware-crowd](https://github.com/fpco/wai-middleware-crowd/blob/master/.travis.yml) - [commercialhaskell/all-cabal-hashes-tool](https://github.com/commercialhaskell/all-cabal-hashes-tool/blob/master/.travis.yml) ## Future enhancements Once Travis whitelists the stack .deb files, we'll be able to simply include stack in the `addons` section, and automatically use the newest version of stack, avoiding that complicated `before_install` section This is being tracked in the [apt-source-whitelist](https://github.com/travis-ci/apt-source-whitelist/pull/7) and [apt-package-whitelist](https://github.com/travis-ci/apt-package-whitelist/issues/379) issue trackers. stack-1.9.3.1/doc/yaml_configuration.md0000644000000000000000000010407713455666157016171 0ustar0000000000000000
# YAML Configuration This page is intended to fully document all configuration options available in the stack.yaml file. Note that this page is likely to be both *incomplete* and sometimes *inaccurate*. If you see such cases, please update the page, and if you're not sure how, open an issue labeled "question". The stack.yaml configuration options break down into [project-specific](#project-specific-config) options in: - `/stack.yaml` and [non-project-specific](#non-project-specific-config) options in: - `/etc/stack/config.yaml` -- for system global non-project default options - `~/.stack/config.yaml` -- for user non-project default options - The project file itself may also contain non-project specific options *Note:* When stack is invoked outside a stack project it will source project specific options from `~/.stack/global-project/stack.yaml`. When stack is invoked inside a stack project, only options from `/stack.yaml` are used, and `~/.stack/global-project/stack.yaml` is ignored. *Note 2:* A common source of confusion is the distinction between configuration in a `stack.yaml` file versus a cabal file. If you're trying to understand this breakdown, see [stack vs cabal config](stack_yaml_vs_cabal_package_file.md). ## Project-specific config Project-specific options are only valid in the `stack.yaml` file local to a project, not in the user or global config files. > Note: We define **project** to mean a directory that contains a `stack.yaml` > file, which specifies how to build a set of packages. We define **package** to > be a package with a `.cabal` file or Hpack `package.yaml` file. In your project-specific options, you specify both **which local packages** to build and **which dependencies to use** when building these packages. Unlike the user's local packages, these dependencies aren't built by default. They only get built when needed. Shadowing semantics, described [here](http://docs.haskellstack.org/en/stable/architecture/#shadowing), are applied to your configuration. So, if you add a package to your `packages` list, it will be used even if you're using a snapshot that specifies a particular version. Similarly, `extra-deps` will shadow the version specified in the resolver. ### resolver Specifies which snapshot is to be used for this project. A snapshot defines a GHC version, a number of packages available for installation, and various settings like build flags. It is called a resolver since a snapshot states how dependencies are resolved. There are currently four resolver types: * LTS Haskell snapshots, e.g. `resolver: lts-2.14` * Stackage Nightly snapshot, e.g. `resolver: nightly-2015-06-16` * No snapshot, just use packages shipped with the compiler * For GHC this looks like `resolver: ghc-7.10.2` * For GHCJS this looks like `resolver: ghcjs-0.1.0_ghc-7.10.2`. * [Custom snapshot](custom_snapshot.md) Each of these resolvers will also determine what constraints are placed on the compiler version. See the [compiler-check](#compiler-check) option for some additional control over compiler version. ### packages and extra-deps _NOTE_ The contents of this section have changed significantly since extensible snapshots were implemented (see: [writeup](https://www.fpcomplete.com/blog/2017/07/stacks-new-extensible-snapshots) and [PR #3249](https://github.com/commercialhaskell/stack/pull/3249)). Most old syntax is still supported with newer versions of Stack, but will not be documented here. Instead, this section contains the recommended syntax as of Stack v1.6.0. There are two types of packages that can be defined in your `stack.yaml` file: * __Project packages__, those which you are actually working on in your current project. These are local file paths in your project directory. * __Extra dependencies__, which are packages provided locally on top of the snapshot definition of available packages. These can come from Hackage (or an alternative package index you've defined, see [package-indices](#package-indices)), an HTTP(S) or local archive, a Git or Mercurial repository, or a local file path. These two sets of packages are both installed into your local package database within your project. However, beyond that, they are completely different: * Project packages will be built by default with a `stack build` without specific targets. Extra dependencies will only be built if they are depended upon. * Test suites and benchmarks may be run for project packages. They are never run for extra dependencies. The `packages` key is a simple list of file paths, which will be treated as relative to the directory containing your `stack.yaml` file. For example: ```yaml packages: - . - dir1/dir2 ``` Each package directory or location specified must have a valid cabal file or hpack `package.yaml` file present. Note that the subdirectories of the directory are not searched for cabal files. Subdirectories will have to be specified as independent items in the list of packages. When the `packages` field is not present, it defaults to looking for a package in the project's root directory: ```yaml packages: - . ``` The `extra-deps` key is given a list of all extra dependencies. If omitted, it is taken as the empty list, e.g.: ```yaml extra-deps: [] ``` It supports four different styles of values: #### Package index Packages can be stated by a name/version combination, which will be looked up in the package index (by default, Hackage). The basic syntax for this is: ```yaml extra-deps: - acme-missiles-0.3 ``` Using this syntax, the most recent Cabal file revision available will be used. For more reproducibility of builds, it is recommended to state the SHA256 hash of the cabal file contents as well, like this: ```yaml extra-deps: - acme-missiles-0.3@sha256:2ba66a092a32593880a87fb00f3213762d7bca65a687d45965778deb8694c5d1 ``` Or a specific revision number, with `0` being the original file: ```yaml extra-deps: - acme-missiles-0.3@rev:0 ``` Note that specifying via SHA256 is slightly more resilient in that it does not rely on correct ordering in the package index, while revision number is likely simpler to use. In practice, both should guarantee equally reproducible build plans. #### Local file path Like `packages`, local file paths can be used in `extra-deps`, and will be relative to the directory containing the `stack.yaml` file. ```yaml extra-deps: - vendor/somelib ``` Note that if a local directory can be parsed as a package identifier, Stack will treat it as a package identifier. In other words, if you have a local directory named `foo-1.2.3`, instead of: ```yaml extra-deps: - foo-1.2.3 ``` You should use the following to be explicit: ```yaml extra-deps: - ./foo-1.2.3 ``` #### Git and Mercurial repos You can give a Git or Mercurial repo at a specific commit, and Stack will clone that repo. ```yaml extra-deps: - git: git@github.com:commercialhaskell/stack.git commit: 6a86ee32e5b869a877151f74064572225e1a0398 - git: git@github.com:snoyberg/http-client.git commit: "a5f4f3" - hg: https://example.com/hg/repo commit: da39a3ee5e6b4b0d3255bfef95601890afd80709 ``` __NOTE__ It is highly recommended that you only use SHA1 values for a Git or Mercurial commit. Other values may work, but they are not officially supported, and may result in unexpected behavior (namely, Stack will not automatically pull to update to new versions). Another problem with this is that your build will not be deterministic, because when someone else tries to build the project they can get a different checkout of the package. A common practice in the Haskell world is to use "megarepos", or repositories with multiple packages in various subdirectories. Some common examples include [wai](https://github.com/yesodweb/wai/) and [digestive-functors](https://github.com/jaspervdj/digestive-functors). To support this, you may also specify `subdirs` for repositories, e.g.: ```yaml extra-deps: - git: git@github.com:yesodweb/wai commit: 2f8a8e1b771829f4a8a77c0111352ce45a14c30f subdirs: - auto-update - wai ``` Since v1.7.1, you can specify packages from GitHub repository name using `github`: ```yaml extra-deps: - github: snoyberg/http-client commit: a5f4f30f01366738f913968163d856366d7e0342 ``` If unspecified, `subdirs` defaults to `['.']` meaning looking for a package in the root of the repo.. Note that if you specify a value of `subdirs`, then `'.'` is _not_ included by default and needs to be explicitly specified if a required package is found in the top-level directory of the repository. #### Archives (HTTP(S) or local filepath) This one's pretty straightforward: you can use HTTP and HTTPS URLs and local filepaths referring to either tarballs or ZIP files. __NOTE__ Stack assumes that these files never change after downloading to avoid needing to make an HTTP request on each build. ```yaml extra-deps: - https://example.com/foo/bar/baz-0.0.2.tar.gz - archive: http://github.com/yesodweb/wai/archive/2f8a8e1b771829f4a8a77c0111352ce45a14c30f.zip subdirs: - wai - warp - archive: ../acme-missiles-0.3.tar.gz sha256: e563d8b524017a06b32768c4db8eff1f822f3fb22a90320b7e414402647b735b ``` Note that HTTP(S) URLs also support `subdirs` like repos to allow for archives of megarepos. In order to leverage this, use `location: http://...`. ### flags Flags can be set for each package separately, e.g. ```yaml flags: package-name: flag-name: true ``` If a specified flag is different than the one specified for a snapshot package, then the snapshot package will automatically be promoted to be an extra-dep. ### image The image settings are used for the creation of container images using `stack image container`, e.g. ```yaml image: containers: - base: "fpco/stack-build" add: static: /data/static ``` `base` is the docker image that will be used to built upon. The `add` lines allow you to add additional directories to your image. You can specify the name of the image using `name` (otherwise it defaults to the same as your project). You can also specify `entrypoints`. By default all your executables are placed in `/usr/local/bin`, but you can specify a list using `executables` to only add some. When you specify `entrypoints`, multiple containers will be built: a project container, and one container for each entrypoint. For example the following configuration: ```yaml image: containers: - name: myproject base: fpco/stack-run add: production/app-backend/conf/: /etc/app-backend entrypoints: - app-backend ``` will build one container tagged `myproject:latest` which contains the project including the `/etc/app-backend` configuration data. Another container tagged `myproject-app-backend:latest` based on the `myproject:latest` will additionally contain the logic for starting the `app-backend` entrypoint. ### user-message A user-message is inserted by `stack init` when it omits packages or adds external dependencies. For example: ```yaml user-message: ! 'Warning: Some packages were found to be incompatible with the resolver and have been left commented out in the packages section. Warning: Specified resolver could not satisfy all dependencies. Some external packages have been added as dependencies. You can omit this message by removing it from stack.yaml ' ``` This messages is displayed every time the config is loaded by stack and serves as a reminder for the user to review the configuration and make any changes if needed. The user can delete this message if the generated configuration is acceptable. ## Non-project-specific config Non-project config options may go in the global config (`/etc/stack/config.yaml`) or the user config (`~/.stack/config.yaml`). ### docker See [Docker integration](docker_integration.md#configuration). ### nix (since 0.1.10.0) See [Nix integration](nix_integration.md#configuration). ### connection-count Integer indicating how many simultaneous downloads are allowed to happen Default: `8` ### hide-th-loading Strip out the "Loading ..." lines from GHC build output, produced when using Template Haskell Default: `true` ### latest-snapshot-url URL providing a JSON with information on the latest LTS and Nightly snapshots, used for automatic project configuration. Default: `https://www.stackage.org/download/snapshots.json` ### local-bin-path Target directory for `stack install` and `stack build --copy-bins`. Default: `~/.local/bin` ### package-indices ```yaml package-indices: - name: Hackage download-prefix: https://s3.amazonaws.com/hackage.fpcomplete.com/package/ # HTTP location of the package index http: https://s3.amazonaws.com/hackage.fpcomplete.com/01-index.tar.gz # Or, if using Hackage Security below, give the root URL: http: https://s3.amazonaws.com/hackage.fpcomplete.com/ # optional fields, both default to false require-hashes: false # Starting with stack 1.4, we default to using Hackage Security hackage-security: keyids: ["deadbeef", "12345"] # list of all approved keys key-threshold: 3 # number of keys required ``` One thing you should be aware of: if you change the contents of package-version combination by setting a different package index, this *can* have an effect on other projects by installing into your shared snapshot database. Note that older versions of Stack supported Git-based indices. This feature has since been removed. A line such as: ```yaml git: https://github.com/commercialhaskell/all-cabal-hashes.git gpg-verify: false ``` Will now be ignored. __IMPORTANT__ Hackage and its mirrors typically have two index files available: `00-index.tar.gz` and `01-index.tar.gz`. The former is a legacy file for backwards compatibility. It does not contain the cabal file revisions produced by Hackage, and therefore _will not work_ with most snapshots. Instead, you need to use `01-index.tar.gz` to ensure that exact revisions can be found, ensuring more reproducible builds. ### system-ghc Enables or disables using the GHC available on the PATH. Useful to enable if you want to save the time, bandwidth or storage space needed to setup an isolated GHC. Default is `false` unless the [Docker](docker_integration.md) or [Nix](nix_integration.md) integration is enabled. In a Nix-enabled configuration, stack is incompatible with `system-ghc: false`. ```yaml # Turn on system GHC system-ghc: true ``` ### install-ghc Whether or not to automatically install GHC when necessary. Since Stack 1.5.0, the default is `true`, which means Stack will not ask you before downloading and installing GHC. ### skip-ghc-check Should we skip the check to confirm that your system GHC version (on the PATH) matches what your project expects? Default is `false`. ### require-stack-version Require a version of stack within the specified range ([cabal-style](https://www.haskell.org/cabal/users-guide/developing-packages.html#build-information)) to be used for this project. Example: `require-stack-version: "== 0.1.*"` Default: `"-any"` ### arch/os Set the architecture and operating system for GHC, build directories, etc. Values are those recognized by Cabal, e.g.: arch: i386, x86_64 os: windows, linux You likely only ever want to change the arch value. This can also be set via the command line. ### extra-include-dirs/extra-lib-dirs A list of extra paths to be searched for header files and libraries, respectively. Paths should be absolute ```yaml extra-include-dirs: - /opt/foo/include extra-lib-dirs: - /opt/foo/lib ``` Since these are system-dependent absolute paths, it is recommended that you specify these in your `config.yaml` within the stack root (usually, `~/.stack`). If you control the build environment in your project's ``stack.yaml``, perhaps through docker or other means, then it may well make sense to include these there as well. ### with-gcc Specify a path to gcc explicitly, rather than relying on the normal path resolution. ```yaml with-gcc: /usr/local/bin/gcc-5 ``` ### with-hpack Use an Hpack executable, rather than using the bundled Hpack. ```yaml with-hpack: /usr/local/bin/hpack ``` ### compiler-check (Since 0.1.4) Specifies how the compiler version in the resolver is matched against concrete versions. Valid values: * `match-minor`: make sure that the first three components match, but allow patch-level differences. For example< 7.8.4.1 and 7.8.4.2 would both match 7.8.4. This is useful to allow for custom patch levels of a compiler. This is the default * `match-exact`: the entire version number must match precisely * `newer-minor`: the third component can be increased, e.g. if your resolver is `ghc-7.10.1`, then 7.10.2 will also be allowed. This was the default up through stack 0.1.3 ### compiler (Since 0.1.7) Overrides the compiler version in the resolver. Note that the `compiler-check` flag also applies to the version numbers. This uses the same syntax as compiler resolvers like `ghc-7.10.2` or `ghcjs-0.1.0.20150924_ghc-7.10.2` (version used for the 'old-base' version of GHCJS). While it's useful to override the compiler for a variety of reasons, the main usecase is to use GHCJS with a stackage snapshot, like this: ```yaml resolver: lts-3.10 compiler: ghcjs-0.1.0.20150924_ghc-7.10.2 compiler-check: match-exact ``` ### ghc-options (Since 0.1.4) Allows specifying per-package and global GHC options: ```yaml ghc-options: # All packages "$locals": -Wall "$targets": -Werror "$everything": -O2 some-package: -DSOME_CPP_FLAG ``` Since 1.6.0, setting a GHC options for a specific package will automatically promote it to a local package (much like setting a custom package flag). However, setting options via `$everything` on all flags will not do so (see [Github discussion](https://github.com/commercialhaskell/stack/issues/849#issuecomment-320892095) for reasoning). This can lead to unpredictable behavior by affecting your snapshot packages. The behavior of the `$locals`, `$targets`, and `$everything` special keys mirrors the behavior for the [`apply-ghc-options` setting](#apply-ghc-options), which affects command line parameters. NOTE: Prior to version 1.6.0, the `$locals`, `$targets`, and `$everything` keys were not supported. Instead, you could use `"*"` for the behavior represented now by `$everything`. It is highly recommended to switch to the new, more expressive, keys. ### apply-ghc-options (Since 0.1.6) Which packages do ghc-options on the command line get applied to? Before 0.1.6, the default value was `targets` ```yaml apply-ghc-options: locals # all local packages, the default # apply-ghc-options: targets # all local packages that are targets # apply-ghc-options: everything # applied even to snapshot and extra-deps ``` Note that `everything` is a slightly dangerous value, as it can break invariants about your snapshot database. ### rebuild-ghc-options (Since 0.1.6) Should we rebuild a package when its GHC options change? Before 0.1.6, this was a non-configurable true. However, in most cases, the flag is used to affect optimization levels and warning behavior, for which GHC itself doesn't actually recompile the modules anyway. Therefore, the new behavior is to not recompile on an options change, but this behavior can be changed back with the following: ```yaml rebuild-ghc-options: true ``` ### ghc-variant (Since 0.1.5) Specify a variant binary distribution of GHC to use. Known values: * `standard`: This is the default, uses the standard GHC binary distribution * `integersimple`: Use a GHC bindist that uses [integer-simple instead of GMP](https://ghc.haskell.org/trac/ghc/wiki/ReplacingGMPNotes) * any other value: Use a custom GHC bindist. You should specify [setup-info](#setup-info) so `stack setup` knows where to download it, or pass the `stack setup --ghc-bindist` argument on the command-line This option is incompatible with `system-ghc: true`. ### ghc-build (Since 1.3.0) Specify a specialized architecture bindist to use. Normally this is determined automatically, but you can override the autodetected value here. Possible arguments include `standard`, `gmp4`, `tinfo6`, and `nopie`. ### setup-info (Since 0.1.5) Allows overriding from where tools like GHC and msys2 (on Windows) are downloaded. Most useful for specifying locations of custom GHC binary distributions (for use with the [ghc-variant](#ghc-variant) option): ```yaml setup-info: ghc: windows32-custom-foo: 7.10.2: url: "https://example.com/ghc-7.10.2-i386-unknown-mingw32-foo.tar.xz" ``` Or without using `ghc-variant`: ```yaml setup-info: "https://raw.githubusercontent.com/fpco/stackage-content/master/stack/stack-setup-2.yaml" ``` `url` may be either URL or (since 1.2.0) absolute file path. ### pvp-bounds (Since 0.1.5) __NOTE__ As of Stack 1.6.0, this feature does not reliably work, due to issues with the Cabal library's printer. Stack will generate a warning when a lossy conversion occurs, in which case you may need to disable this setting. See [#3550](https://github.com/commercialhaskell/stack/issues/3550) for more information. When using the `sdist` and `upload` commands, this setting determines whether the cabal file's dependencies should be modified to reflect PVP lower and upper bounds. Values are `none` (unchanged), `upper` (add upper bounds), `lower` (add lower bounds), and both (and upper and lower bounds). The algorithm it follows is: * If an upper or lower bound already exists on a dependency, it's left alone * When adding a lower bound, we look at the current version specified by stack.yaml, and set it as the lower bound (e.g., `foo >= 1.2.3`) * When adding an upper bound, we require less than the next major version (e.g., `foo < 1.3`) ```yaml pvp-bounds: none ``` For more information, see [the announcement blog post](https://www.fpcomplete.com/blog/2015/09/stack-pvp). __NOTE__ Since Stack 1.5.0, each of the values listed above supports adding `-revision` to the end of each value, e.g. `pvp-bounds: both-revision`. This means that, when uploading to Hackage, Stack will first upload your tarball with an unmodified `.cabal` file, and then upload a cabal file revision with the PVP bounds added. This can be useful—especially combined with the [Stackage no-revisions feature](http://www.snoyman.com/blog/2017/04/stackages-no-revisions-field)—as a method to ensure PVP compliance without having to proactively fix bounds issues for Stackage maintenance. ### modify-code-page (Since 0.1.6) Modify the code page for UTF-8 output when running on Windows. Default behavior is to modify. ```yaml modify-code-page: false ``` ### explicit-setup-deps (Since 0.1.6) Decide whether a custom `Setup.hs` script should be run with an explicit list of dependencies, based on the dependencies of the package itself. It associates the name of a local package with a boolean. When it's `true`, the `Setup.hs` script is built with an explicit list of packages. When it's `false` (default), the `Setup.hs` script is built without access to the local DB, but can access any package in the snapshot / global DB. Note that in the future, this will be unnecessary, once Cabal provides full support for explicit Setup.hs dependencies. ```yaml explicit-setup-deps: "*": true # change the default entropy: false # override the new default for one package ``` NOTE: since 1.4.0, Stack has support for Cabal's `custom-setup` block (introduced in Cabal 1.24). If a `custom-setup` block is provided in a `.cabal` file, it will override the setting of `explicit-setup-deps`, and instead rely on the stated dependencies. ### allow-newer (Since 0.1.7) Ignore version bounds in .cabal files. Default is false. ```yaml allow-newer: true ``` Note that this also ignores lower bounds. The name "allow-newer" is chosen to match the commonly used cabal option. ### allow-different-user (Since 1.0.1) Allow users other than the owner of the stack root directory (typically `~/.stack`) to use the stack installation. The default is `false`. POSIX systems only. ```yaml allow-different-user: true ``` The intention of this option is to prevent file permission problems, for example as the result of a `stack` command executed under `sudo`. The option is automatically enabled when `stack` is re-spawned in a Docker process. ### build (Since 1.1.0) Allows setting build options which are usually specified on the CLI. Here are the settings with their defaults: ```yaml build: library-profiling: false executable-profiling: false copy-bins: false prefetch: false keep-going: false keep-tmp-files: false # NOTE: global usage of haddock can cause build failures when documentation is # incorrectly formatted. This could also affect scripts which use stack. haddock: false haddock-arguments: haddock-args: [] # Additional arguments passed to haddock, --haddock-arguments # haddock-args: # - "--css=/home/user/my-css" open-haddocks: false # --open haddock-deps: false # if unspecified, defaults to true if haddock is set haddock-internal: false # These are inadvisable to use in your global configuration, as they make the # stack build CLI behave quite differently. test: false test-arguments: rerun-tests: true # Rerun successful tests additional-args: [] # --test-arguments # additional-args: # - "--fail-fast" coverage: false no-run-tests: false bench: false benchmark-opts: benchmark-arguments: "" # benchmark-arguments: "--csv bench.csv" no-run-benchmarks: false force-dirty: false reconfigure: false cabal-verbose: false split-objs: false # Since 1.8 interleaved-output: false ``` The meanings of these settings correspond directly with the CLI flags of the same name. See the [build command docs](build_command.md) and the [users guide](GUIDE.md#the-build-command) for more info. ### dump-logs (Since 1.3.0) Control which log output from local non-dependency packages to print to the console. By default, Stack will only do this when building a single target package or if the log contains warnings, to avoid generating unnecessarily verbose output. ```yaml dump-logs: none # don't dump logs even if they contain warnings dump-logs: warning # default: dump logs that contain warnings dump-logs: all # dump all logs for local non-dependency packages ``` ### templates Templates used with `stack new` have a number of parameters that affect the generated code. These can be set for all new projects you create. The result of them can be observed in the generated LICENSE and cabal files. The value for all of these parameters must be strings. The parameters are: `author-email`, `author-name`, `category`, `copyright`, `year` and `github-username`. * _author-email_ - sets the `maintainer` property in cabal * _author-name_ - sets the `author` property in cabal and the name used in LICENSE * _category_ - sets the `category` property in cabal. This is used in Hackage. For examples of categories see [Packages by category](https://hackage.haskell.org/packages/). It makes sense for `category` to be set on a per project basis because it is uncommon for all projects a user creates to belong to the same category. The category can be set per project by passing `-p "category:value"` to the `stack new` command. * _copyright_ - sets the `copyright` property in cabal. It is typically the name of the holder of the copyright on the package and the year(s) from which copyright is claimed. For example: `Copyright (c) 2006-2007 Joe Bloggs` * _year_ - if `copyright` is not specified, `year` and `author-name` are used to generate the copyright property in cabal. If `year` is not specified, it defaults to the current year. * _github-username_ - used to generate `homepage` and `source-repository` in cabal. For instance `github-username: myusername` and `stack new my-project new-template` would result: ```yaml homepage: http://github.com/myusername/my-project#readme source-repository head type: git location: https://github.com/myusername/my-project ``` These properties can be set in `config.yaml` as follows: ```yaml templates: params: author-name: Your Name author-email: youremail@example.com category: Your Projects Category copyright: 'Copyright (c) 2018 Your Name' github-username: yourusername ``` Additionally, `stack new` can automatically initialize source control repositories in the directories it creates. Source control tools can be specified with the `scm-init` option. At the moment, only `git` is supported. ```yaml templates: scm-init: git ``` ### save-hackage-creds Controls whether, when using `stack upload`, the user's Hackage username and password are stored in a local file. Default: true. ```yaml save-hackage-creds: true ``` Since 1.5.0 ### hackage-base-url Sets the address of the Hackage server to upload the package to. Default is `https://hackage.haskell.org/`. ```yaml hackage-base-url: https://hackage.example.com/ ``` Since 1.9.1 ### ignore-revision-mismatch Cabal files in packages can be specified via exact revisions to deal with Hackage revision metadata. The default behavior of Stack (since 1.6.0) is to fail if an exact match is not found. In some cases (specifically, when using a legacy `00-index.tar.gz` file), users may wish to allow a mismatch. In such cases, you can change `ignore-revision-mismatch` from `false` to `true`. ```yaml ignore-revision-mismatch: false ``` For more information, see [the Github issue #3520 discussion](https://github.com/commercialhaskell/stack/issues/3520). Since 1.6.0 ### urls Customize the URLs where `stack` looks for snapshot build plans. The default configuration is ```yaml urls: latest-snapshot: https://www.stackage.org/download/snapshots.json lts-build-plans: https://raw.githubusercontent.com/fpco/lts-haskell/master/ nightly-build-plans: https://raw.githubusercontent.com/fpco/stackage-nightly/master/ ``` **Note:** The `latest-snapshot-url` field has been deprecated in favor of `latest-snapshot` and will be removed in a future version of `stack`. ### jobs Specifies how many build tasks should be run in parallel. This can be overloaded on the commandline via `-jN`, for example `-j2`. The default is to use the number of processors reported by your CPU. One usage for this might be to avoid running out of memory by setting it to 1, like this: ```yaml jobs: 1 ``` ### work-dir Specifies relative path of work directory (default is `.stack-work`. This can also be specified by env var or cli flag, in particular, the earlier items in this list take precedence: 1. `--work-dir DIR` passed on the commandline 2. `work-dir` in stack.yaml 3. `STACK_WORK` environment variable Since 0.1.10.0 ### skip-msys Skips checking for and installing msys2 when stack is setting up the environment. This is only useful on Windows machines, and usually doesn't make sense in project configurations, just in `config.yaml`. Defaults to `false`, so if this is used, it only really makes sense to use it like this: ```yaml skip-msys: true ``` Since 0.1.2.0 ### concurrent-tests This option specifies whether test-suites should be executed concurrently with each-other. The default for this is true, since this is usually fine and it often means that tests can complete earlier. However, if some test-suites require exclusive access to some resource, or require a great deal of CPU or memory resources, then it makes sense to set this to `false` (the default is `true`). ```yaml concurrent-tests: false ``` Since 0.1.2.0 ### extra-path This option specifies additional directories to prepend to the PATH environment variable. These will be used when resolving the location of executables, and will also be visible in the `PATH` variable of processes run by stack. For example, to prepend `/path-to-some-dep/bin` to your PATH: ```yaml extra-path: - /path-to-some-dep/bin ``` One thing to note is that other paths added by stack - things like the project's bin dir and the compiler's bin dir - will take precedence over those specified here (the automatic paths get prepended). Since 0.1.4.0 ### local-programs-path This overrides the location of the programs directory, where tools like ghc and msys get installed. On most systems, this defaults to a folder called `programs` within the stack root directory. On windows, if the `LOCALAPPDATA` environment variable exists, then it defaults to `$LOCALAPPDATA/Programs/stack/`, which follows windows conventions. Since 1.3.0 ### default-template This option specifies which template to use with `stack new`, when none is specified. The default is called `new-template`. The other templates are listed in [the stack-templates repo](https://github.com/commercialhaskell/stack-templates/). ### stack-colors Stack uses styles to format some of its output. The default styles do not work well with every terminal theme. This option specifies stack's output styles, allowing new styles to replace the defaults. The option is used as `stack-colors: `, where `` is a colon-delimited sequence of key=value, 'key' is a style name and 'value' is a semicolon-delimited list of 'ANSI' SGR (Select Graphic Rendition) control codes (in decimal). Use the command `stack ls stack-colors --basic` to see the current sequence. The 'ANSI' standards refer to (1) standard ECMA-48 'Control Functions for Coded Character Sets' (5th edition, 1991); (2) extensions in ITU-T Recommendation (previously CCITT Recommendation) T.416 (03/93) 'Information Technology – Open Document Architecture (ODA) and Interchange Format: Character Content Architectures' (also published as ISO/IEC International Standard 8613-6); and (3) further extensions used by 'XTerm', a terminal emulator for the X Window System. The 'ANSI' SGR codes are described in a [Wikipedia article](http://en.wikipedia.org/wiki/ANSI_escape_code) and those codes supported on current versions of Windows in [Microsoft's documentation](https://docs.microsoft.com/en-us/windows/console/console-virtual-terminal-sequences). For example, users of the popular [Solarized Dark](https://ethanschoonover.com/solarized/) terminal theme might wish to set the styles as follows: ```yaml stack-colors: error=31:good=32:shell=35:dir=34:recommendation=32:target=95:module=35:package-component=95 ``` The styles can also be set at the command line using the equivalent `--stack-colors=` global option. Styles set at the command line take precedence over those set in a yaml configuration file. stack-1.9.3.1/src/setup-shim/StackSetupShim.hs0000644000000000000000000000247413015755774017333 0ustar0000000000000000module StackSetupShim where import Main import Distribution.PackageDescription (PackageDescription, emptyHookedBuildInfo) import Distribution.Simple import Distribution.Simple.Build import Distribution.Simple.Setup (ReplFlags, fromFlag, replDistPref, replVerbosity) import Distribution.Simple.LocalBuildInfo (LocalBuildInfo) import System.Environment (getArgs) mainOverride :: IO () mainOverride = do args <- getArgs if "repl" `elem` args && "stack-initial-build-steps" `elem` args then do defaultMainWithHooks simpleUserHooks { preRepl = \_ _ -> return emptyHookedBuildInfo , replHook = stackReplHook , postRepl = \_ _ _ _ -> return () } else main stackReplHook :: PackageDescription -> LocalBuildInfo -> UserHooks -> ReplFlags -> [String] -> IO () stackReplHook pkg_descr lbi hooks flags args = do let distPref = fromFlag (replDistPref flags) verbosity = fromFlag (replVerbosity flags) case args of ("stack-initial-build-steps":rest) | null rest -> initialBuildSteps distPref pkg_descr lbi verbosity | otherwise -> fail "Misuse of running Setup.hs with stack-initial-build-steps, expected no arguments" _ -> replHook simpleUserHooks pkg_descr lbi hooks flags args stack-1.9.3.1/stack.yaml0000644000000000000000000000234513455671116013164 0ustar0000000000000000resolver: lts-11.22 # docker: # enable: true # repo: fpco/stack-full # image: # containers: # - base: "fpco/stack-base" # see ./etc/docker/stack-base/Dockerfile # name: "fpco/stack-test" nix: # --nix on the command-line to enable. packages: - zlib - unzip flags: stack: hide-dependency-versions: true supported-build: true extra-deps: - Cabal-2.4.0.1@rev:0 - cabal-install-2.4.0.0@rev:1 - resolv-0.1.1.2@rev:0 - infer-license-0.2.0@rev:0 #for hpack-0.31 - hpack-0.31.1@rev:0 - http-api-data-0.3.8.1@rev:1 - githash-0.1.3.0@rev:0 - yaml-0.10.4.0@rev:0 #for hpack-0.31 - windns-0.1.0.0@rev:0 - hackage-security-0.5.3.0@rev:2 - cabal-doctest-1.0.6@rev:2 - rio-0.1.9.2@rev:0 - unliftio-0.2.10@rev:0 # Avoid https://github.com/commercialhaskell/stack/issues/4125 # (triggered because later versions of persistent transitively depends # on haskell-src-exts, which needs the 'happy' build tool) # THIS IS FIXED AS OF STACK 1.8, but keep these here until next major # version to maintain the ability to build stack with older versions. - persistent-2.7.1@rev:0 - persistent-sqlite-2.6.4@rev:0 - resourcet-1.1.11@rev:0 - conduit-1.2.13.1@rev:0 - conduit-extra-1.2.3.2@rev:0 ghc-options: "$locals": -fhide-source-paths stack-1.9.3.1/test/package-dump/ghc-7.10.txt0000644000000000000000000015720712535613373016404 0ustar0000000000000000name: ghc version: 7.10.1 id: ghc-7.10.1-325809317787a897b7a97d646ceaa3a3 key: ghc_EMlWrQ42XY0BNVbSrKixqY license: BSD3 maintainer: glasgow-haskell-users@haskell.org homepage: http://www.haskell.org/ghc/ synopsis: The GHC API description: GHC's functionality can be useful for more things than just compiling Haskell programs. Important use cases are programs that analyse (and perhaps transform) Haskell code. Others include loading Haskell code dynamically in a GHCi-like manner. For this reason, a lot of GHC's functionality is made available through this package. category: Development author: The GHC Team exposed: False exposed-modules: Avail BasicTypes ConLike DataCon PatSyn Demand Debug Exception GhcMonad Hooks Id IdInfo Lexeme Literal Llvm Llvm.AbsSyn Llvm.MetaData Llvm.PpLlvm Llvm.Types LlvmCodeGen LlvmCodeGen.Base LlvmCodeGen.CodeGen LlvmCodeGen.Data LlvmCodeGen.Ppr LlvmCodeGen.Regs LlvmMangler MkId Module Name NameEnv NameSet OccName RdrName SrcLoc UniqSupply Unique Var VarEnv VarSet UnVarGraph BlockId CLabel Cmm CmmBuildInfoTables CmmPipeline CmmCallConv CmmCommonBlockElim CmmContFlowOpt CmmExpr CmmInfo CmmLex CmmLint CmmLive CmmMachOp CmmNode CmmOpt CmmParse CmmProcPoint CmmSink CmmType CmmUtils CmmLayoutStack MkGraph PprBase PprC PprCmm PprCmmDecl PprCmmExpr Bitmap CodeGen.Platform CodeGen.Platform.ARM CodeGen.Platform.ARM64 CodeGen.Platform.NoRegs CodeGen.Platform.PPC CodeGen.Platform.PPC_Darwin CodeGen.Platform.SPARC CodeGen.Platform.X86 CodeGen.Platform.X86_64 CgUtils StgCmm StgCmmBind StgCmmClosure StgCmmCon StgCmmEnv StgCmmExpr StgCmmForeign StgCmmHeap StgCmmHpc StgCmmArgRep StgCmmLayout StgCmmMonad StgCmmPrim StgCmmProf StgCmmTicky StgCmmUtils StgCmmExtCode SMRep CoreArity CoreFVs CoreLint CorePrep CoreSubst CoreSyn TrieMap CoreTidy CoreUnfold CoreUtils MkCore PprCore Check Coverage Desugar DsArrows DsBinds DsCCall DsExpr DsForeign DsGRHSs DsListComp DsMonad DsUtils Match MatchCon MatchLit HsBinds HsDecls HsDoc HsExpr HsImpExp HsLit PlaceHolder HsPat HsSyn HsTypes HsUtils BinIface BuildTyCl IfaceEnv IfaceSyn IfaceType LoadIface MkIface TcIface FlagChecker Annotations BreakArray CmdLineParser CodeOutput Config Constants DriverMkDepend DriverPhases PipelineMonad DriverPipeline DynFlags ErrUtils Finder GHC GhcMake GhcPlugins DynamicLoading HeaderInfo HscMain HscStats HscTypes InteractiveEval InteractiveEvalTypes PackageConfig Packages PlatformConstants Plugins TcPluginM PprTyThing StaticFlags StaticPtrTable SysTools TidyPgm Ctype HaddockUtils Lexer OptCoercion Parser RdrHsSyn ApiAnnotation ForeignCall PrelInfo PrelNames PrelRules PrimOp TysPrim TysWiredIn CostCentre ProfInit SCCfinal RnBinds RnEnv RnExpr RnHsDoc RnNames RnPat RnSource RnSplice RnTypes CoreMonad CSE FloatIn FloatOut LiberateCase OccurAnal SAT SetLevels SimplCore SimplEnv SimplMonad SimplUtils Simplify SimplStg StgStats UnariseStg Rules SpecConstr Specialise CoreToStg StgLint StgSyn CallArity DmdAnal WorkWrap WwLib FamInst Inst TcAnnotations TcArrows TcBinds TcClassDcl TcDefaults TcDeriv TcEnv TcExpr TcForeign TcGenDeriv TcGenGenerics TcHsSyn TcHsType TcInstDcls TcMType TcValidity TcMatches TcPat TcPatSyn TcRnDriver TcRnMonad TcRnTypes TcRules TcSimplify TcErrors TcTyClsDecls TcTyDecls TcType TcEvidence TcUnify TcInteract TcCanonical TcFlatten TcSMonad TcTypeNats TcSplice Class Coercion FamInstEnv FunDeps InstEnv TyCon CoAxiom Kind Type TypeRep Unify Bag Binary BooleanFormula BufWrite Digraph Encoding FastBool FastFunctions FastMutInt FastString FastTypes Fingerprint FiniteMap GraphBase GraphColor GraphOps GraphPpr IOEnv ListSetOps Maybes MonadUtils OrdList Outputable Pair Panic Pretty Serialized State Stream StringBuffer UniqFM UniqSet Util ExtsCompat46 Vectorise.Builtins.Base Vectorise.Builtins.Initialise Vectorise.Builtins Vectorise.Monad.Base Vectorise.Monad.Naming Vectorise.Monad.Local Vectorise.Monad.Global Vectorise.Monad.InstEnv Vectorise.Monad Vectorise.Utils.Base Vectorise.Utils.Closure Vectorise.Utils.Hoisting Vectorise.Utils.PADict Vectorise.Utils.Poly Vectorise.Utils Vectorise.Generic.Description Vectorise.Generic.PAMethods Vectorise.Generic.PADict Vectorise.Generic.PData Vectorise.Type.Env Vectorise.Type.Type Vectorise.Type.TyConDecl Vectorise.Type.Classify Vectorise.Convert Vectorise.Vect Vectorise.Var Vectorise.Env Vectorise.Exp Vectorise Hoopl.Dataflow Hoopl AsmCodeGen TargetReg NCGMonad Instruction Size Reg RegClass PIC Platform CPrim X86.Regs X86.RegInfo X86.Instr X86.Cond X86.Ppr X86.CodeGen PPC.Regs PPC.RegInfo PPC.Instr PPC.Cond PPC.Ppr PPC.CodeGen SPARC.Base SPARC.Regs SPARC.Imm SPARC.AddrMode SPARC.Cond SPARC.Instr SPARC.Stack SPARC.ShortcutJump SPARC.Ppr SPARC.CodeGen SPARC.CodeGen.Amode SPARC.CodeGen.Base SPARC.CodeGen.CondCode SPARC.CodeGen.Gen32 SPARC.CodeGen.Gen64 SPARC.CodeGen.Sanity SPARC.CodeGen.Expand RegAlloc.Liveness RegAlloc.Graph.Main RegAlloc.Graph.Stats RegAlloc.Graph.ArchBase RegAlloc.Graph.ArchX86 RegAlloc.Graph.Coalesce RegAlloc.Graph.Spill RegAlloc.Graph.SpillClean RegAlloc.Graph.SpillCost RegAlloc.Graph.TrivColorable RegAlloc.Linear.Main RegAlloc.Linear.JoinToTargets RegAlloc.Linear.State RegAlloc.Linear.Stats RegAlloc.Linear.FreeRegs RegAlloc.Linear.StackMap RegAlloc.Linear.Base RegAlloc.Linear.X86.FreeRegs RegAlloc.Linear.X86_64.FreeRegs RegAlloc.Linear.PPC.FreeRegs RegAlloc.Linear.SPARC.FreeRegs Dwarf Dwarf.Types Dwarf.Constants DsMeta Convert ByteCodeAsm ByteCodeGen ByteCodeInstr ByteCodeItbls ByteCodeLink Debugger LibFFI Linker ObjLink RtClosureInspect DebuggerUtils trusted: False import-dirs: /opt/ghc/7.10.1/lib/ghc-7.10.1/ghc_EMlWrQ42XY0BNVbSrKixqY library-dirs: /opt/ghc/7.10.1/lib/ghc-7.10.1/ghc_EMlWrQ42XY0BNVbSrKixqY data-dir: /opt/ghc/7.10.1/share/x86_64-linux-ghc-7.10.1/ghc-7.10.1 hs-libraries: HSghc-7.10.1-EMlWrQ42XY0BNVbSrKixqY include-dirs: /opt/ghc/7.10.1/lib/ghc-7.10.1/ghc_EMlWrQ42XY0BNVbSrKixqY/include depends: array-0.5.1.0-e29cdbe82692341ebb7ce6e2798294f9 base-4.8.0.0-1b689eb8d72c4d4cc88f445839c1f01a bin-package-db-0.0.0.0-708fc7d634a370b311371a5bcde40b62 bytestring-0.10.6.0-0909f8f31271f3d75749190bf2ee35db containers-0.5.6.2-2114032c163425cc264e6e1169dc2f6d directory-1.2.2.0-b4959b472d9eee380c6b32291ade29e0 filepath-1.4.0.0-40d643aa87258c186441a1f8f3e13ca6 hoopl-3.10.0.2-8c8dfc4c3140e5f7c982da224c3cb1f0 hpc-0.6.0.2-ac9064885aa8cb08a93314222939ead4 process-1.2.3.0-3b1e9bca6ac38225806ff7bbf3f845b1 template-haskell-2.10.0.0-e895139a0ffff267d412e3d0191ce93b time-1.5.0.1-e17a9220d438435579d2914e90774246 transformers-0.4.2.0-c1a7bb855a176fe475d7b665301cd48f unix-2.7.1.0-e5915eb989e568b732bc7286b0d0817f haddock-interfaces: /opt/ghc/7.10.1/share/doc/ghc/html/libraries/ghc-7.10.1/ghc.haddock haddock-html: /opt/ghc/7.10.1/share/doc/ghc/html/libraries/ghc-7.10.1 pkgroot: "/opt/ghc/7.10.1/lib/ghc-7.10.1" --- name: haskeline version: 0.7.2.1 id: haskeline-0.7.2.1-a646e1ddf1a755ca5b5775dcb2ef8d8b key: haske_IlDhIe25uAn0WJY379Nu1M license: BSD3 copyright: (c) Judah Jacobson maintainer: Judah Jacobson stability: Experimental homepage: http://trac.haskell.org/haskeline synopsis: A command-line interface for user input, written in Haskell. description: Haskeline provides a user interface for line input in command-line programs. This library is similar in purpose to readline, but since it is written in Haskell it is (hopefully) more easily used in other Haskell programs. . Haskeline runs both on POSIX-compatible systems and on Windows. category: User Interfaces author: Judah Jacobson exposed: True exposed-modules: System.Console.Haskeline System.Console.Haskeline.Completion System.Console.Haskeline.MonadException System.Console.Haskeline.History System.Console.Haskeline.IO hidden-modules: System.Console.Haskeline.Backend System.Console.Haskeline.Backend.WCWidth System.Console.Haskeline.Command System.Console.Haskeline.Command.Completion System.Console.Haskeline.Command.History System.Console.Haskeline.Command.KillRing System.Console.Haskeline.Directory System.Console.Haskeline.Emacs System.Console.Haskeline.InputT System.Console.Haskeline.Key System.Console.Haskeline.LineState System.Console.Haskeline.Monads System.Console.Haskeline.Prefs System.Console.Haskeline.RunCommand System.Console.Haskeline.Term System.Console.Haskeline.Command.Undo System.Console.Haskeline.Vi System.Console.Haskeline.Recover System.Console.Haskeline.Backend.Posix System.Console.Haskeline.Backend.Posix.Encoder System.Console.Haskeline.Backend.DumbTerm System.Console.Haskeline.Backend.Terminfo trusted: False import-dirs: /opt/ghc/7.10.1/lib/ghc-7.10.1/haske_IlDhIe25uAn0WJY379Nu1M library-dirs: /opt/ghc/7.10.1/lib/ghc-7.10.1/haske_IlDhIe25uAn0WJY379Nu1M data-dir: /opt/ghc/7.10.1/share/x86_64-linux-ghc-7.10.1/haskeline-0.7.2.1 hs-libraries: HShaskeline-0.7.2.1-IlDhIe25uAn0WJY379Nu1M depends: base-4.8.0.0-1b689eb8d72c4d4cc88f445839c1f01a bytestring-0.10.6.0-0909f8f31271f3d75749190bf2ee35db containers-0.5.6.2-2114032c163425cc264e6e1169dc2f6d directory-1.2.2.0-b4959b472d9eee380c6b32291ade29e0 filepath-1.4.0.0-40d643aa87258c186441a1f8f3e13ca6 terminfo-0.4.0.1-75199801b414a3f4c9de438be2a4e967 transformers-0.4.2.0-c1a7bb855a176fe475d7b665301cd48f unix-2.7.1.0-e5915eb989e568b732bc7286b0d0817f haddock-interfaces: /opt/ghc/7.10.1/share/doc/ghc/html/libraries/haskeline-0.7.2.1/haskeline.haddock haddock-html: /opt/ghc/7.10.1/share/doc/ghc/html/libraries/haskeline-0.7.2.1 pkgroot: "/opt/ghc/7.10.1/lib/ghc-7.10.1" --- name: terminfo version: 0.4.0.1 id: terminfo-0.4.0.1-75199801b414a3f4c9de438be2a4e967 key: termi_7qZwBlx3clR8sTBilJl253 license: BSD3 copyright: (c) Judah Jacobson maintainer: Judah Jacobson stability: Stable homepage: https://github.com/judah/terminfo synopsis: Haskell bindings to the terminfo library. description: This library provides an interface to the terminfo database (via bindings to the curses library). allows POSIX systems to interact with a variety of terminals using a standard set of capabilities. category: User Interfaces author: Judah Jacobson exposed: True exposed-modules: System.Console.Terminfo System.Console.Terminfo.Base System.Console.Terminfo.Cursor System.Console.Terminfo.Color System.Console.Terminfo.Edit System.Console.Terminfo.Effects System.Console.Terminfo.Keys trusted: False import-dirs: /opt/ghc/7.10.1/lib/ghc-7.10.1/termi_7qZwBlx3clR8sTBilJl253 library-dirs: /opt/ghc/7.10.1/lib/ghc-7.10.1/termi_7qZwBlx3clR8sTBilJl253 data-dir: /opt/ghc/7.10.1/share/x86_64-linux-ghc-7.10.1/terminfo-0.4.0.1 hs-libraries: HSterminfo-0.4.0.1-7qZwBlx3clR8sTBilJl253 extra-libraries: tinfo includes: ncurses.h term.h depends: base-4.8.0.0-1b689eb8d72c4d4cc88f445839c1f01a haddock-interfaces: /opt/ghc/7.10.1/share/doc/ghc/html/libraries/terminfo-0.4.0.1/terminfo.haddock haddock-html: /opt/ghc/7.10.1/share/doc/ghc/html/libraries/terminfo-0.4.0.1 pkgroot: "/opt/ghc/7.10.1/lib/ghc-7.10.1" --- name: xhtml version: 3000.2.1 id: xhtml-3000.2.1-7de0560ea74b173b7313fc2303cc6c58 key: xhtml_0mVDYvYGgNUBWShvlDofr1 license: BSD3 copyright: Bjorn Bringert 2004-2006, Andy Gill and the Oregon Graduate Institute of Science and Technology, 1999-2001 maintainer: Chris Dornan stability: Stable homepage: https://github.com/haskell/xhtml synopsis: An XHTML combinator library description: This package provides combinators for producing XHTML 1.0, including the Strict, Transitional and Frameset variants. category: Web, XML, Pretty Printer author: Bjorn Bringert exposed: True exposed-modules: Text.XHtml Text.XHtml.Frameset Text.XHtml.Strict Text.XHtml.Transitional Text.XHtml.Debug Text.XHtml.Table hidden-modules: Text.XHtml.Strict.Attributes Text.XHtml.Strict.Elements Text.XHtml.Frameset.Attributes Text.XHtml.Frameset.Elements Text.XHtml.Transitional.Attributes Text.XHtml.Transitional.Elements Text.XHtml.BlockTable Text.XHtml.Extras Text.XHtml.Internals trusted: False import-dirs: /opt/ghc/7.10.1/lib/ghc-7.10.1/xhtml_0mVDYvYGgNUBWShvlDofr1 library-dirs: /opt/ghc/7.10.1/lib/ghc-7.10.1/xhtml_0mVDYvYGgNUBWShvlDofr1 data-dir: /opt/ghc/7.10.1/share/x86_64-linux-ghc-7.10.1/xhtml-3000.2.1 hs-libraries: HSxhtml-3000.2.1-0mVDYvYGgNUBWShvlDofr1 depends: base-4.8.0.0-1b689eb8d72c4d4cc88f445839c1f01a haddock-interfaces: /opt/ghc/7.10.1/share/doc/ghc/html/libraries/xhtml-3000.2.1/xhtml.haddock haddock-html: /opt/ghc/7.10.1/share/doc/ghc/html/libraries/xhtml-3000.2.1 pkgroot: "/opt/ghc/7.10.1/lib/ghc-7.10.1" --- name: transformers version: 0.4.2.0 id: transformers-0.4.2.0-c1a7bb855a176fe475d7b665301cd48f key: trans_ALYlebOVzVI4kxbFX5SGhm license: BSD3 maintainer: Ross Paterson synopsis: Concrete functor and monad transformers description: A portable library of functor and monad transformers, inspired by the paper \"Functional Programming with Overloading and Higher-Order Polymorphism\", by Mark P Jones, in /Advanced School of Functional Programming/, 1995 (). . This package contains: . * the monad transformer class (in "Control.Monad.Trans.Class") and IO monad class (in "Control.Monad.IO.Class") . * concrete functor and monad transformers, each with associated operations and functions to lift operations associated with other transformers. . The package can be used on its own in portable Haskell code, in which case operations need to be manually lifted through transformer stacks (see "Control.Monad.Trans.Class" for some examples). Alternatively, it can be used with the non-portable monad classes in the @mtl@ or @monads-tf@ packages, which automatically lift operations introduced by monad transformers through other transformers. category: Control author: Andy Gill, Ross Paterson exposed: True exposed-modules: Control.Applicative.Backwards Control.Applicative.Lift Control.Monad.IO.Class Control.Monad.Signatures Control.Monad.Trans.Class Control.Monad.Trans.Cont Control.Monad.Trans.Except Control.Monad.Trans.Error Control.Monad.Trans.Identity Control.Monad.Trans.List Control.Monad.Trans.Maybe Control.Monad.Trans.Reader Control.Monad.Trans.RWS Control.Monad.Trans.RWS.Lazy Control.Monad.Trans.RWS.Strict Control.Monad.Trans.State Control.Monad.Trans.State.Lazy Control.Monad.Trans.State.Strict Control.Monad.Trans.Writer Control.Monad.Trans.Writer.Lazy Control.Monad.Trans.Writer.Strict Data.Functor.Classes Data.Functor.Compose Data.Functor.Constant Data.Functor.Product Data.Functor.Reverse Data.Functor.Sum trusted: False import-dirs: /opt/ghc/7.10.1/lib/ghc-7.10.1/trans_ALYlebOVzVI4kxbFX5SGhm library-dirs: /opt/ghc/7.10.1/lib/ghc-7.10.1/trans_ALYlebOVzVI4kxbFX5SGhm data-dir: /opt/ghc/7.10.1/share/x86_64-linux-ghc-7.10.1/transformers-0.4.2.0 hs-libraries: HStransformers-0.4.2.0-ALYlebOVzVI4kxbFX5SGhm depends: base-4.8.0.0-1b689eb8d72c4d4cc88f445839c1f01a haddock-interfaces: /opt/ghc/7.10.1/share/doc/ghc/html/libraries/transformers-0.4.2.0/transformers.haddock haddock-html: /opt/ghc/7.10.1/share/doc/ghc/html/libraries/transformers-0.4.2.0 pkgroot: "/opt/ghc/7.10.1/lib/ghc-7.10.1" --- name: hoopl version: 3.10.0.2 id: hoopl-3.10.0.2-8c8dfc4c3140e5f7c982da224c3cb1f0 key: hoopl_JxODiSRz1e84NbH6nnZuUk license: BSD3 maintainer: nr@cs.tufts.edu homepage: http://ghc.cs.tufts.edu/hoopl/ synopsis: A library to support dataflow analysis and optimization description: Higher-order optimization library . See /Norman Ramsey, Joao Dias, and Simon Peyton Jones./ /(2010)/ for more details. category: Compilers/Interpreters author: Norman Ramsey, Joao Dias, Simon Marlow and Simon Peyton Jones exposed: True exposed-modules: Compiler.Hoopl Compiler.Hoopl.Internals Compiler.Hoopl.Wrappers Compiler.Hoopl.Passes.Dominator Compiler.Hoopl.Passes.DList hidden-modules: Compiler.Hoopl.Checkpoint Compiler.Hoopl.Collections Compiler.Hoopl.Combinators Compiler.Hoopl.Dataflow Compiler.Hoopl.Debug Compiler.Hoopl.Block Compiler.Hoopl.Graph Compiler.Hoopl.Label Compiler.Hoopl.MkGraph Compiler.Hoopl.Fuel Compiler.Hoopl.Pointed Compiler.Hoopl.Shape Compiler.Hoopl.Show Compiler.Hoopl.Unique Compiler.Hoopl.XUtil trusted: False import-dirs: /opt/ghc/7.10.1/lib/ghc-7.10.1/hoopl_JxODiSRz1e84NbH6nnZuUk library-dirs: /opt/ghc/7.10.1/lib/ghc-7.10.1/hoopl_JxODiSRz1e84NbH6nnZuUk data-dir: /opt/ghc/7.10.1/share/x86_64-linux-ghc-7.10.1/hoopl-3.10.0.2 hs-libraries: HShoopl-3.10.0.2-JxODiSRz1e84NbH6nnZuUk depends: base-4.8.0.0-1b689eb8d72c4d4cc88f445839c1f01a containers-0.5.6.2-2114032c163425cc264e6e1169dc2f6d haddock-interfaces: /opt/ghc/7.10.1/share/doc/ghc/html/libraries/hoopl-3.10.0.2/hoopl.haddock haddock-html: /opt/ghc/7.10.1/share/doc/ghc/html/libraries/hoopl-3.10.0.2 pkgroot: "/opt/ghc/7.10.1/lib/ghc-7.10.1" --- name: bin-package-db version: 0.0.0.0 id: bin-package-db-0.0.0.0-708fc7d634a370b311371a5bcde40b62 key: binpa_JNoexmBMuO8C771QaIy3YN license: BSD3 maintainer: ghc-devs@haskell.org synopsis: The GHC compiler's view of the GHC package database format description: This library is shared between GHC and ghc-pkg and is used by GHC to read package databases. . It only deals with the subset of the package database that the compiler cares about: modules paths etc and not package metadata like description, authors etc. It is thus not a library interface to ghc-pkg and is *not* suitable for modifying GHC package databases. . The package database format and this library are constructed in such a way that while ghc-pkg depends on Cabal, the GHC library and program do not have to depend on Cabal. exposed: True exposed-modules: GHC.PackageDb trusted: False import-dirs: /opt/ghc/7.10.1/lib/ghc-7.10.1/binpa_JNoexmBMuO8C771QaIy3YN library-dirs: /opt/ghc/7.10.1/lib/ghc-7.10.1/binpa_JNoexmBMuO8C771QaIy3YN data-dir: /opt/ghc/7.10.1/share/x86_64-linux-ghc-7.10.1/bin-package-db-0.0.0.0 hs-libraries: HSbin-package-db-0.0.0.0-JNoexmBMuO8C771QaIy3YN depends: base-4.8.0.0-1b689eb8d72c4d4cc88f445839c1f01a binary-0.7.3.0-0f543654a1ae447e0d4d0bbfc1bb704e bytestring-0.10.6.0-0909f8f31271f3d75749190bf2ee35db directory-1.2.2.0-b4959b472d9eee380c6b32291ade29e0 filepath-1.4.0.0-40d643aa87258c186441a1f8f3e13ca6 haddock-interfaces: /opt/ghc/7.10.1/share/doc/ghc/html/libraries/bin-package-db-0.0.0.0/bin-package-db.haddock haddock-html: /opt/ghc/7.10.1/share/doc/ghc/html/libraries/bin-package-db-0.0.0.0 pkgroot: "/opt/ghc/7.10.1/lib/ghc-7.10.1" --- name: Cabal version: 1.22.2.0 id: Cabal-1.22.2.0-9f7cae2e98cca225e3d159c1e1bc773c key: Cabal_HWT8QvVfJLn2ubvobpycJY license: BSD3 copyright: 2003-2006, Isaac Jones 2005-2011, Duncan Coutts maintainer: cabal-devel@haskell.org homepage: http://www.haskell.org/cabal/ synopsis: A framework for packaging Haskell software description: The Haskell Common Architecture for Building Applications and Libraries: a framework defining a common interface for authors to more easily build their Haskell applications in a portable way. . The Haskell Cabal is part of a larger infrastructure for distributing, organizing, and cataloging Haskell libraries and tools. category: Distribution author: Isaac Jones Duncan Coutts exposed: True exposed-modules: Distribution.Compat.CreatePipe Distribution.Compat.Environment Distribution.Compat.Exception Distribution.Compat.ReadP Distribution.Compiler Distribution.InstalledPackageInfo Distribution.License Distribution.Make Distribution.ModuleName Distribution.Package Distribution.PackageDescription Distribution.PackageDescription.Check Distribution.PackageDescription.Configuration Distribution.PackageDescription.Parse Distribution.PackageDescription.PrettyPrint Distribution.PackageDescription.Utils Distribution.ParseUtils Distribution.ReadE Distribution.Simple Distribution.Simple.Bench Distribution.Simple.Build Distribution.Simple.Build.Macros Distribution.Simple.Build.PathsModule Distribution.Simple.BuildPaths Distribution.Simple.BuildTarget Distribution.Simple.CCompiler Distribution.Simple.Command Distribution.Simple.Compiler Distribution.Simple.Configure Distribution.Simple.GHC Distribution.Simple.GHCJS Distribution.Simple.Haddock Distribution.Simple.HaskellSuite Distribution.Simple.Hpc Distribution.Simple.Install Distribution.Simple.InstallDirs Distribution.Simple.JHC Distribution.Simple.LHC Distribution.Simple.LocalBuildInfo Distribution.Simple.PackageIndex Distribution.Simple.PreProcess Distribution.Simple.PreProcess.Unlit Distribution.Simple.Program Distribution.Simple.Program.Ar Distribution.Simple.Program.Builtin Distribution.Simple.Program.Db Distribution.Simple.Program.Find Distribution.Simple.Program.GHC Distribution.Simple.Program.HcPkg Distribution.Simple.Program.Hpc Distribution.Simple.Program.Ld Distribution.Simple.Program.Run Distribution.Simple.Program.Script Distribution.Simple.Program.Strip Distribution.Simple.Program.Types Distribution.Simple.Register Distribution.Simple.Setup Distribution.Simple.SrcDist Distribution.Simple.Test Distribution.Simple.Test.ExeV10 Distribution.Simple.Test.LibV09 Distribution.Simple.Test.Log Distribution.Simple.UHC Distribution.Simple.UserHooks Distribution.Simple.Utils Distribution.System Distribution.TestSuite Distribution.Text Distribution.Utils.NubList Distribution.Verbosity Distribution.Version Language.Haskell.Extension hidden-modules: Distribution.Compat.Binary Distribution.Compat.CopyFile Distribution.Compat.TempFile Distribution.GetOpt Distribution.Simple.GHC.Internal Distribution.Simple.GHC.IPI641 Distribution.Simple.GHC.IPI642 Distribution.Simple.GHC.ImplInfo Paths_Cabal trusted: False import-dirs: /opt/ghc/7.10.1/lib/ghc-7.10.1/Cabal_HWT8QvVfJLn2ubvobpycJY library-dirs: /opt/ghc/7.10.1/lib/ghc-7.10.1/Cabal_HWT8QvVfJLn2ubvobpycJY data-dir: /opt/ghc/7.10.1/share/x86_64-linux-ghc-7.10.1/Cabal-1.22.2.0 hs-libraries: HSCabal-1.22.2.0-HWT8QvVfJLn2ubvobpycJY depends: array-0.5.1.0-e29cdbe82692341ebb7ce6e2798294f9 base-4.8.0.0-1b689eb8d72c4d4cc88f445839c1f01a binary-0.7.3.0-0f543654a1ae447e0d4d0bbfc1bb704e bytestring-0.10.6.0-0909f8f31271f3d75749190bf2ee35db containers-0.5.6.2-2114032c163425cc264e6e1169dc2f6d deepseq-1.4.1.1-c1376f846fa170f2cc2cb2e57b203339 directory-1.2.2.0-b4959b472d9eee380c6b32291ade29e0 filepath-1.4.0.0-40d643aa87258c186441a1f8f3e13ca6 pretty-1.1.2.0-0d4e1eca3b0cfcebe20b9405f7bdaca9 process-1.2.3.0-3b1e9bca6ac38225806ff7bbf3f845b1 time-1.5.0.1-e17a9220d438435579d2914e90774246 unix-2.7.1.0-e5915eb989e568b732bc7286b0d0817f haddock-interfaces: /opt/ghc/7.10.1/share/doc/ghc/html/libraries/Cabal-1.22.2.0/Cabal.haddock haddock-html: /opt/ghc/7.10.1/share/doc/ghc/html/libraries/Cabal-1.22.2.0 pkgroot: "/opt/ghc/7.10.1/lib/ghc-7.10.1" --- name: binary version: 0.7.3.0 id: binary-0.7.3.0-0f543654a1ae447e0d4d0bbfc1bb704e key: binar_EKE3c9Lmxb3DQpU0fPtru6 license: BSD3 maintainer: Lennart Kolmodin, Don Stewart stability: provisional homepage: https://github.com/kolmodin/binary synopsis: Binary serialisation for Haskell values using lazy ByteStrings description: Efficient, pure binary serialisation using lazy ByteStrings. Haskell values may be encoded to and from binary formats, written to disk as binary, or sent over the network. The format used can be automatically generated, or you can choose to implement a custom format if needed. Serialisation speeds of over 1 G\/sec have been observed, so this library should be suitable for high performance scenarios. category: Data, Parsing author: Lennart Kolmodin exposed: True exposed-modules: Data.Binary Data.Binary.Put Data.Binary.Get Data.Binary.Get.Internal Data.Binary.Builder Data.Binary.Builder.Internal hidden-modules: Data.Binary.Builder.Base Data.Binary.Class Data.Binary.Generic trusted: False import-dirs: /opt/ghc/7.10.1/lib/ghc-7.10.1/binar_EKE3c9Lmxb3DQpU0fPtru6 library-dirs: /opt/ghc/7.10.1/lib/ghc-7.10.1/binar_EKE3c9Lmxb3DQpU0fPtru6 data-dir: /opt/ghc/7.10.1/share/x86_64-linux-ghc-7.10.1/binary-0.7.3.0 hs-libraries: HSbinary-0.7.3.0-EKE3c9Lmxb3DQpU0fPtru6 depends: array-0.5.1.0-e29cdbe82692341ebb7ce6e2798294f9 base-4.8.0.0-1b689eb8d72c4d4cc88f445839c1f01a bytestring-0.10.6.0-0909f8f31271f3d75749190bf2ee35db containers-0.5.6.2-2114032c163425cc264e6e1169dc2f6d haddock-interfaces: /opt/ghc/7.10.1/share/doc/ghc/html/libraries/binary-0.7.3.0/binary.haddock haddock-html: /opt/ghc/7.10.1/share/doc/ghc/html/libraries/binary-0.7.3.0 pkgroot: "/opt/ghc/7.10.1/lib/ghc-7.10.1" --- name: template-haskell version: 2.10.0.0 id: template-haskell-2.10.0.0-e895139a0ffff267d412e3d0191ce93b key: templ_BVMCZyLwIlfGfcqqzyUAI8 license: BSD3 maintainer: libraries@haskell.org synopsis: Support library for Template Haskell description: This package provides modules containing facilities for manipulating Haskell source code using Template Haskell. . See for more information. category: Template Haskell exposed: True exposed-modules: Language.Haskell.TH Language.Haskell.TH.Lib Language.Haskell.TH.Ppr Language.Haskell.TH.PprLib Language.Haskell.TH.Quote Language.Haskell.TH.Syntax hidden-modules: Language.Haskell.TH.Lib.Map trusted: False import-dirs: /opt/ghc/7.10.1/lib/ghc-7.10.1/templ_BVMCZyLwIlfGfcqqzyUAI8 library-dirs: /opt/ghc/7.10.1/lib/ghc-7.10.1/templ_BVMCZyLwIlfGfcqqzyUAI8 data-dir: /opt/ghc/7.10.1/share/x86_64-linux-ghc-7.10.1/template-haskell-2.10.0.0 hs-libraries: HStemplate-haskell-2.10.0.0-BVMCZyLwIlfGfcqqzyUAI8 depends: base-4.8.0.0-1b689eb8d72c4d4cc88f445839c1f01a pretty-1.1.2.0-0d4e1eca3b0cfcebe20b9405f7bdaca9 haddock-interfaces: /opt/ghc/7.10.1/share/doc/ghc/html/libraries/template-haskell-2.10.0.0/template-haskell.haddock haddock-html: /opt/ghc/7.10.1/share/doc/ghc/html/libraries/template-haskell-2.10.0.0 pkgroot: "/opt/ghc/7.10.1/lib/ghc-7.10.1" --- name: pretty version: 1.1.2.0 id: pretty-1.1.2.0-0d4e1eca3b0cfcebe20b9405f7bdaca9 key: prett_7jIfj8VCGFf1WS0tIQ1XSZ license: BSD3 maintainer: David Terei stability: Stable homepage: http://github.com/haskell/pretty synopsis: Pretty-printing library description: This package contains a pretty-printing library, a set of API's that provides a way to easily print out text in a consistent format of your choosing. This is useful for compilers and related tools. . This library was originally designed by John Hughes's and has since been heavily modified by Simon Peyton Jones. category: Text exposed: True exposed-modules: Text.PrettyPrint Text.PrettyPrint.HughesPJ Text.PrettyPrint.HughesPJClass trusted: False import-dirs: /opt/ghc/7.10.1/lib/ghc-7.10.1/prett_7jIfj8VCGFf1WS0tIQ1XSZ library-dirs: /opt/ghc/7.10.1/lib/ghc-7.10.1/prett_7jIfj8VCGFf1WS0tIQ1XSZ data-dir: /opt/ghc/7.10.1/share/x86_64-linux-ghc-7.10.1/pretty-1.1.2.0 hs-libraries: HSpretty-1.1.2.0-7jIfj8VCGFf1WS0tIQ1XSZ depends: base-4.8.0.0-1b689eb8d72c4d4cc88f445839c1f01a deepseq-1.4.1.1-c1376f846fa170f2cc2cb2e57b203339 ghc-prim-0.4.0.0-7c945cc0c41d3b7b70f3edd125671166 haddock-interfaces: /opt/ghc/7.10.1/share/doc/ghc/html/libraries/pretty-1.1.2.0/pretty.haddock haddock-html: /opt/ghc/7.10.1/share/doc/ghc/html/libraries/pretty-1.1.2.0 pkgroot: "/opt/ghc/7.10.1/lib/ghc-7.10.1" --- name: hpc version: 0.6.0.2 id: hpc-0.6.0.2-ac9064885aa8cb08a93314222939ead4 key: hpc_CmUUQl5bURfBueJrdYfNs3 license: BSD3 maintainer: ghc-devs@haskell.org synopsis: Code Coverage Library for Haskell description: This package provides the code coverage library for Haskell. . See for more information. category: Control author: Andy Gill exposed: True exposed-modules: Trace.Hpc.Util Trace.Hpc.Mix Trace.Hpc.Tix Trace.Hpc.Reflect trusted: False import-dirs: /opt/ghc/7.10.1/lib/ghc-7.10.1/hpc_CmUUQl5bURfBueJrdYfNs3 library-dirs: /opt/ghc/7.10.1/lib/ghc-7.10.1/hpc_CmUUQl5bURfBueJrdYfNs3 data-dir: /opt/ghc/7.10.1/share/x86_64-linux-ghc-7.10.1/hpc-0.6.0.2 hs-libraries: HShpc-0.6.0.2-CmUUQl5bURfBueJrdYfNs3 depends: base-4.8.0.0-1b689eb8d72c4d4cc88f445839c1f01a containers-0.5.6.2-2114032c163425cc264e6e1169dc2f6d directory-1.2.2.0-b4959b472d9eee380c6b32291ade29e0 filepath-1.4.0.0-40d643aa87258c186441a1f8f3e13ca6 time-1.5.0.1-e17a9220d438435579d2914e90774246 haddock-interfaces: /opt/ghc/7.10.1/share/doc/ghc/html/libraries/hpc-0.6.0.2/hpc.haddock haddock-html: /opt/ghc/7.10.1/share/doc/ghc/html/libraries/hpc-0.6.0.2 pkgroot: "/opt/ghc/7.10.1/lib/ghc-7.10.1" --- name: process version: 1.2.3.0 id: process-1.2.3.0-3b1e9bca6ac38225806ff7bbf3f845b1 key: proce_0hwN3CTKynhHQqQkChnSdH license: BSD3 maintainer: libraries@haskell.org synopsis: Process libraries description: This package contains libraries for dealing with system processes. category: System exposed: True exposed-modules: System.Cmd System.Process System.Process.Internals trusted: False import-dirs: /opt/ghc/7.10.1/lib/ghc-7.10.1/proce_0hwN3CTKynhHQqQkChnSdH library-dirs: /opt/ghc/7.10.1/lib/ghc-7.10.1/proce_0hwN3CTKynhHQqQkChnSdH data-dir: /opt/ghc/7.10.1/share/x86_64-linux-ghc-7.10.1/process-1.2.3.0 hs-libraries: HSprocess-1.2.3.0-0hwN3CTKynhHQqQkChnSdH include-dirs: /opt/ghc/7.10.1/lib/ghc-7.10.1/proce_0hwN3CTKynhHQqQkChnSdH/include includes: runProcess.h depends: base-4.8.0.0-1b689eb8d72c4d4cc88f445839c1f01a deepseq-1.4.1.1-c1376f846fa170f2cc2cb2e57b203339 directory-1.2.2.0-b4959b472d9eee380c6b32291ade29e0 filepath-1.4.0.0-40d643aa87258c186441a1f8f3e13ca6 unix-2.7.1.0-e5915eb989e568b732bc7286b0d0817f haddock-interfaces: /opt/ghc/7.10.1/share/doc/ghc/html/libraries/process-1.2.3.0/process.haddock haddock-html: /opt/ghc/7.10.1/share/doc/ghc/html/libraries/process-1.2.3.0 pkgroot: "/opt/ghc/7.10.1/lib/ghc-7.10.1" --- name: directory version: 1.2.2.0 id: directory-1.2.2.0-b4959b472d9eee380c6b32291ade29e0 key: direc_3TcTyYedch32o1zTH2MR00 license: BSD3 maintainer: libraries@haskell.org synopsis: Platform-agnostic library for filesystem operations description: This library provides a basic set of operations for manipulating files and directories in a portable way. category: System exposed: True exposed-modules: System.Directory trusted: False import-dirs: /opt/ghc/7.10.1/lib/ghc-7.10.1/direc_3TcTyYedch32o1zTH2MR00 library-dirs: /opt/ghc/7.10.1/lib/ghc-7.10.1/direc_3TcTyYedch32o1zTH2MR00 data-dir: /opt/ghc/7.10.1/share/x86_64-linux-ghc-7.10.1/directory-1.2.2.0 hs-libraries: HSdirectory-1.2.2.0-3TcTyYedch32o1zTH2MR00 include-dirs: /opt/ghc/7.10.1/lib/ghc-7.10.1/direc_3TcTyYedch32o1zTH2MR00/include includes: HsDirectory.h depends: base-4.8.0.0-1b689eb8d72c4d4cc88f445839c1f01a filepath-1.4.0.0-40d643aa87258c186441a1f8f3e13ca6 time-1.5.0.1-e17a9220d438435579d2914e90774246 unix-2.7.1.0-e5915eb989e568b732bc7286b0d0817f haddock-interfaces: /opt/ghc/7.10.1/share/doc/ghc/html/libraries/directory-1.2.2.0/directory.haddock haddock-html: /opt/ghc/7.10.1/share/doc/ghc/html/libraries/directory-1.2.2.0 pkgroot: "/opt/ghc/7.10.1/lib/ghc-7.10.1" --- name: unix version: 2.7.1.0 id: unix-2.7.1.0-e5915eb989e568b732bc7286b0d0817f key: unix_G4Yo1pNtYrk8nCq1cx8P9d license: BSD3 maintainer: libraries@haskell.org homepage: https://github.com/haskell/unix synopsis: POSIX functionality description: This package gives you access to the set of operating system services standardised by POSIX 1003.1b (or the IEEE Portable Operating System Interface for Computing Environments - IEEE Std. 1003.1). . The package is not supported under Windows (except under Cygwin). category: System exposed: True exposed-modules: System.Posix System.Posix.ByteString System.Posix.Error System.Posix.Resource System.Posix.Time System.Posix.Unistd System.Posix.User System.Posix.Signals System.Posix.Signals.Exts System.Posix.Semaphore System.Posix.SharedMem System.Posix.ByteString.FilePath System.Posix.Directory System.Posix.Directory.ByteString System.Posix.DynamicLinker.Module System.Posix.DynamicLinker.Module.ByteString System.Posix.DynamicLinker.Prim System.Posix.DynamicLinker.ByteString System.Posix.DynamicLinker System.Posix.Files System.Posix.Files.ByteString System.Posix.IO System.Posix.IO.ByteString System.Posix.Env System.Posix.Env.ByteString System.Posix.Fcntl System.Posix.Process System.Posix.Process.Internals System.Posix.Process.ByteString System.Posix.Temp System.Posix.Temp.ByteString System.Posix.Terminal System.Posix.Terminal.ByteString hidden-modules: System.Posix.Directory.Common System.Posix.DynamicLinker.Common System.Posix.Files.Common System.Posix.IO.Common System.Posix.Process.Common System.Posix.Terminal.Common trusted: False import-dirs: /opt/ghc/7.10.1/lib/ghc-7.10.1/unix_G4Yo1pNtYrk8nCq1cx8P9d library-dirs: /opt/ghc/7.10.1/lib/ghc-7.10.1/unix_G4Yo1pNtYrk8nCq1cx8P9d data-dir: /opt/ghc/7.10.1/share/x86_64-linux-ghc-7.10.1/unix-2.7.1.0 hs-libraries: HSunix-2.7.1.0-G4Yo1pNtYrk8nCq1cx8P9d extra-libraries: rt util dl pthread include-dirs: /opt/ghc/7.10.1/lib/ghc-7.10.1/unix_G4Yo1pNtYrk8nCq1cx8P9d/include includes: HsUnix.h execvpe.h depends: base-4.8.0.0-1b689eb8d72c4d4cc88f445839c1f01a bytestring-0.10.6.0-0909f8f31271f3d75749190bf2ee35db time-1.5.0.1-e17a9220d438435579d2914e90774246 haddock-interfaces: /opt/ghc/7.10.1/share/doc/ghc/html/libraries/unix-2.7.1.0/unix.haddock haddock-html: /opt/ghc/7.10.1/share/doc/ghc/html/libraries/unix-2.7.1.0 pkgroot: "/opt/ghc/7.10.1/lib/ghc-7.10.1" --- name: time version: 1.5.0.1 id: time-1.5.0.1-e17a9220d438435579d2914e90774246 key: time_Hh2clZW6in4HpYHx5bLtb7 license: BSD3 maintainer: stability: stable homepage: https://github.com/haskell/time synopsis: A time library description: A time library category: System author: Ashley Yakeley exposed: True exposed-modules: Data.Time.Calendar Data.Time.Calendar.MonthDay Data.Time.Calendar.OrdinalDate Data.Time.Calendar.WeekDate Data.Time.Calendar.Julian Data.Time.Calendar.Easter Data.Time.Clock Data.Time.Clock.POSIX Data.Time.Clock.TAI Data.Time.LocalTime Data.Time.Format Data.Time hidden-modules: Data.Time.Calendar.Private Data.Time.Calendar.Days Data.Time.Calendar.Gregorian Data.Time.Calendar.JulianYearDay Data.Time.Clock.Scale Data.Time.Clock.UTC Data.Time.Clock.CTimeval Data.Time.Clock.UTCDiff Data.Time.LocalTime.TimeZone Data.Time.LocalTime.TimeOfDay Data.Time.LocalTime.LocalTime Data.Time.Format.Parse Data.Time.Format.Locale trusted: False import-dirs: /opt/ghc/7.10.1/lib/ghc-7.10.1/time_Hh2clZW6in4HpYHx5bLtb7 library-dirs: /opt/ghc/7.10.1/lib/ghc-7.10.1/time_Hh2clZW6in4HpYHx5bLtb7 data-dir: /opt/ghc/7.10.1/share/x86_64-linux-ghc-7.10.1/time-1.5.0.1 hs-libraries: HStime-1.5.0.1-Hh2clZW6in4HpYHx5bLtb7 include-dirs: /opt/ghc/7.10.1/lib/ghc-7.10.1/time_Hh2clZW6in4HpYHx5bLtb7/include depends: base-4.8.0.0-1b689eb8d72c4d4cc88f445839c1f01a deepseq-1.4.1.1-c1376f846fa170f2cc2cb2e57b203339 haddock-interfaces: /opt/ghc/7.10.1/share/doc/ghc/html/libraries/time-1.5.0.1/time.haddock haddock-html: /opt/ghc/7.10.1/share/doc/ghc/html/libraries/time-1.5.0.1 pkgroot: "/opt/ghc/7.10.1/lib/ghc-7.10.1" --- name: containers version: 0.5.6.2 id: containers-0.5.6.2-2114032c163425cc264e6e1169dc2f6d key: conta_47ajk3tbda43DFWyeF3oHQ license: BSD3 maintainer: fox@ucw.cz synopsis: Assorted concrete container types description: This package contains efficient general-purpose implementations of various basic immutable container types. The declared cost of each operation is either worst-case or amortized, but remains valid even if structures are shared. category: Data Structures exposed: True exposed-modules: Data.IntMap Data.IntMap.Lazy Data.IntMap.Strict Data.IntSet Data.Map Data.Map.Lazy Data.Map.Strict Data.Set Data.Graph Data.Sequence Data.Tree hidden-modules: Data.IntMap.Base Data.IntSet.Base Data.Map.Base Data.Set.Base Data.Utils.BitUtil Data.Utils.StrictFold Data.Utils.StrictPair trusted: False import-dirs: /opt/ghc/7.10.1/lib/ghc-7.10.1/conta_47ajk3tbda43DFWyeF3oHQ library-dirs: /opt/ghc/7.10.1/lib/ghc-7.10.1/conta_47ajk3tbda43DFWyeF3oHQ data-dir: /opt/ghc/7.10.1/share/x86_64-linux-ghc-7.10.1/containers-0.5.6.2 hs-libraries: HScontainers-0.5.6.2-47ajk3tbda43DFWyeF3oHQ depends: array-0.5.1.0-e29cdbe82692341ebb7ce6e2798294f9 base-4.8.0.0-1b689eb8d72c4d4cc88f445839c1f01a deepseq-1.4.1.1-c1376f846fa170f2cc2cb2e57b203339 ghc-prim-0.4.0.0-7c945cc0c41d3b7b70f3edd125671166 haddock-interfaces: /opt/ghc/7.10.1/share/doc/ghc/html/libraries/containers-0.5.6.2/containers.haddock haddock-html: /opt/ghc/7.10.1/share/doc/ghc/html/libraries/containers-0.5.6.2 pkgroot: "/opt/ghc/7.10.1/lib/ghc-7.10.1" --- name: bytestring version: 0.10.6.0 id: bytestring-0.10.6.0-0909f8f31271f3d75749190bf2ee35db key: bytes_6vj5EoliHgNHISHCVCb069 license: BSD3 copyright: Copyright (c) Don Stewart 2005-2009, (c) Duncan Coutts 2006-2015, (c) David Roundy 2003-2005, (c) Jasper Van der Jeugt 2010, (c) Simon Meier 2010-2013. maintainer: Duncan Coutts homepage: https://github.com/haskell/bytestring synopsis: Fast, compact, strict and lazy byte strings with a list interface description: An efficient compact, immutable byte string type (both strict and lazy) suitable for binary or 8-bit character data. . The 'ByteString' type represents sequences of bytes or 8-bit characters. It is suitable for high performance use, both in terms of large data quantities, or high speed requirements. The 'ByteString' functions follow the same style as Haskell\'s ordinary lists, so it is easy to convert code from using 'String' to 'ByteString'. . Two 'ByteString' variants are provided: . * Strict 'ByteString's keep the string as a single large array. This makes them convenient for passing data between C and Haskell. . * Lazy 'ByteString's use a lazy list of strict chunks which makes it suitable for I\/O streaming tasks. . The @Char8@ modules provide a character-based view of the same underlying 'ByteString' types. This makes it convenient to handle mixed binary and 8-bit character content (which is common in many file formats and network protocols). . The 'Builder' module provides an efficient way to build up 'ByteString's in an ad-hoc way by repeated concatenation. This is ideal for fast serialisation or pretty printing. . There is also a 'ShortByteString' type which has a lower memory overhead and can can be converted to or from a 'ByteString', but supports very few other operations. It is suitable for keeping many short strings in memory. . 'ByteString's are not designed for Unicode. For Unicode strings you should use the 'Text' type from the @text@ package. . These modules are intended to be imported qualified, to avoid name clashes with "Prelude" functions, e.g. . > import qualified Data.ByteString as BS category: Data author: Don Stewart, Duncan Coutts exposed: True exposed-modules: Data.ByteString Data.ByteString.Char8 Data.ByteString.Unsafe Data.ByteString.Internal Data.ByteString.Lazy Data.ByteString.Lazy.Char8 Data.ByteString.Lazy.Internal Data.ByteString.Short Data.ByteString.Short.Internal Data.ByteString.Builder Data.ByteString.Builder.Extra Data.ByteString.Builder.Prim Data.ByteString.Builder.Internal Data.ByteString.Builder.Prim.Internal Data.ByteString.Lazy.Builder Data.ByteString.Lazy.Builder.Extras Data.ByteString.Lazy.Builder.ASCII hidden-modules: Data.ByteString.Builder.ASCII Data.ByteString.Builder.Prim.Binary Data.ByteString.Builder.Prim.ASCII Data.ByteString.Builder.Prim.Internal.Floating Data.ByteString.Builder.Prim.Internal.UncheckedShifts Data.ByteString.Builder.Prim.Internal.Base16 trusted: False import-dirs: /opt/ghc/7.10.1/lib/ghc-7.10.1/bytes_6vj5EoliHgNHISHCVCb069 library-dirs: /opt/ghc/7.10.1/lib/ghc-7.10.1/bytes_6vj5EoliHgNHISHCVCb069 data-dir: /opt/ghc/7.10.1/share/x86_64-linux-ghc-7.10.1/bytestring-0.10.6.0 hs-libraries: HSbytestring-0.10.6.0-6vj5EoliHgNHISHCVCb069 include-dirs: /opt/ghc/7.10.1/lib/ghc-7.10.1/bytes_6vj5EoliHgNHISHCVCb069/include includes: fpstring.h depends: base-4.8.0.0-1b689eb8d72c4d4cc88f445839c1f01a deepseq-1.4.1.1-c1376f846fa170f2cc2cb2e57b203339 ghc-prim-0.4.0.0-7c945cc0c41d3b7b70f3edd125671166 integer-gmp-1.0.0.0-3c947e5fb6dca14804d9b2793c521b67 haddock-interfaces: /opt/ghc/7.10.1/share/doc/ghc/html/libraries/bytestring-0.10.6.0/bytestring.haddock haddock-html: /opt/ghc/7.10.1/share/doc/ghc/html/libraries/bytestring-0.10.6.0 pkgroot: "/opt/ghc/7.10.1/lib/ghc-7.10.1" --- name: deepseq version: 1.4.1.1 id: deepseq-1.4.1.1-c1376f846fa170f2cc2cb2e57b203339 key: deeps_FpR4obOZALU1lutWnrBldi license: BSD3 maintainer: libraries@haskell.org synopsis: Deep evaluation of data structures description: This package provides methods for fully evaluating data structures (\"deep evaluation\"). Deep evaluation is often used for adding strictness to a program, e.g. in order to force pending exceptions, remove space leaks, or force lazy I/O to happen. It is also useful in parallel programs, to ensure pending work does not migrate to the wrong thread. . The primary use of this package is via the 'deepseq' function, a \"deep\" version of 'seq'. It is implemented on top of an 'NFData' typeclass (\"Normal Form Data\", data structures with no unevaluated components) which defines strategies for fully evaluating different data types. category: Control exposed: True exposed-modules: Control.DeepSeq trusted: False import-dirs: /opt/ghc/7.10.1/lib/ghc-7.10.1/deeps_FpR4obOZALU1lutWnrBldi library-dirs: /opt/ghc/7.10.1/lib/ghc-7.10.1/deeps_FpR4obOZALU1lutWnrBldi data-dir: /opt/ghc/7.10.1/share/x86_64-linux-ghc-7.10.1/deepseq-1.4.1.1 hs-libraries: HSdeepseq-1.4.1.1-FpR4obOZALU1lutWnrBldi depends: array-0.5.1.0-e29cdbe82692341ebb7ce6e2798294f9 base-4.8.0.0-1b689eb8d72c4d4cc88f445839c1f01a haddock-interfaces: /opt/ghc/7.10.1/share/doc/ghc/html/libraries/deepseq-1.4.1.1/deepseq.haddock haddock-html: /opt/ghc/7.10.1/share/doc/ghc/html/libraries/deepseq-1.4.1.1 pkgroot: "/opt/ghc/7.10.1/lib/ghc-7.10.1" --- name: array version: 0.5.1.0 id: array-0.5.1.0-e29cdbe82692341ebb7ce6e2798294f9 key: array_FaHmcBFfuRM8kmZLEY8D5S license: BSD3 maintainer: libraries@haskell.org synopsis: Mutable and immutable arrays description: In addition to providing the "Data.Array" module , this package also defines the classes 'IArray' of immutable arrays and 'MArray' of arrays mutable within appropriate monads, as well as some instances of these classes. category: Data Structures exposed: True exposed-modules: Data.Array Data.Array.Base Data.Array.IArray Data.Array.IO Data.Array.IO.Safe Data.Array.IO.Internals Data.Array.MArray Data.Array.MArray.Safe Data.Array.ST Data.Array.ST.Safe Data.Array.Storable Data.Array.Storable.Safe Data.Array.Storable.Internals Data.Array.Unboxed Data.Array.Unsafe trusted: False import-dirs: /opt/ghc/7.10.1/lib/ghc-7.10.1/array_FaHmcBFfuRM8kmZLEY8D5S library-dirs: /opt/ghc/7.10.1/lib/ghc-7.10.1/array_FaHmcBFfuRM8kmZLEY8D5S data-dir: /opt/ghc/7.10.1/share/x86_64-linux-ghc-7.10.1/array-0.5.1.0 hs-libraries: HSarray-0.5.1.0-FaHmcBFfuRM8kmZLEY8D5S depends: base-4.8.0.0-1b689eb8d72c4d4cc88f445839c1f01a haddock-interfaces: /opt/ghc/7.10.1/share/doc/ghc/html/libraries/array-0.5.1.0/array.haddock haddock-html: /opt/ghc/7.10.1/share/doc/ghc/html/libraries/array-0.5.1.0 pkgroot: "/opt/ghc/7.10.1/lib/ghc-7.10.1" --- name: filepath version: 1.4.0.0 id: filepath-1.4.0.0-40d643aa87258c186441a1f8f3e13ca6 key: filep_5HhyRonfEZoDO205Wm9E4h license: BSD3 copyright: Neil Mitchell 2005-2015 maintainer: Neil Mitchell homepage: https://github.com/haskell/filepath#readme synopsis: Library for manipulating FilePaths in a cross platform way. description: This package provides functionality for manipulating @FilePath@ values, and is shipped with both and the . It provides three modules: . * "System.FilePath.Posix" manipulates POSIX\/Linux style @FilePath@ values (with @\/@ as the path separator). . * "System.FilePath.Windows" manipulates Windows style @FilePath@ values (with either @\\@ or @\/@ as the path separator, and deals with drives). . * "System.FilePath" is an alias for the module appropriate to your platform. . All three modules provide the same API, and the same documentation (calling out differences in the different variants). category: System author: Neil Mitchell exposed: True exposed-modules: System.FilePath System.FilePath.Posix System.FilePath.Windows trusted: False import-dirs: /opt/ghc/7.10.1/lib/ghc-7.10.1/filep_5HhyRonfEZoDO205Wm9E4h library-dirs: /opt/ghc/7.10.1/lib/ghc-7.10.1/filep_5HhyRonfEZoDO205Wm9E4h data-dir: /opt/ghc/7.10.1/share/x86_64-linux-ghc-7.10.1/filepath-1.4.0.0 hs-libraries: HSfilepath-1.4.0.0-5HhyRonfEZoDO205Wm9E4h depends: base-4.8.0.0-1b689eb8d72c4d4cc88f445839c1f01a haddock-interfaces: /opt/ghc/7.10.1/share/doc/ghc/html/libraries/filepath-1.4.0.0/filepath.haddock haddock-html: /opt/ghc/7.10.1/share/doc/ghc/html/libraries/filepath-1.4.0.0 pkgroot: "/opt/ghc/7.10.1/lib/ghc-7.10.1" --- name: base version: 4.8.0.0 id: base-4.8.0.0-1b689eb8d72c4d4cc88f445839c1f01a key: base_I5BErHzyOm07EBNpKBEeUv license: BSD3 maintainer: libraries@haskell.org synopsis: Basic libraries description: This package contains the "Prelude" and its support libraries, and a large collection of useful libraries ranging from data structures to parsing combinators and debugging utilities. category: Prelude exposed: True exposed-modules: Control.Applicative Control.Arrow Control.Category Control.Concurrent Control.Concurrent.Chan Control.Concurrent.MVar Control.Concurrent.QSem Control.Concurrent.QSemN Control.Exception Control.Exception.Base Control.Monad Control.Monad.Fix Control.Monad.Instances Control.Monad.ST Control.Monad.ST.Lazy Control.Monad.ST.Lazy.Safe Control.Monad.ST.Lazy.Unsafe Control.Monad.ST.Safe Control.Monad.ST.Strict Control.Monad.ST.Unsafe Control.Monad.Zip Data.Bifunctor Data.Bits Data.Bool Data.Char Data.Coerce Data.Complex Data.Data Data.Dynamic Data.Either Data.Eq Data.Fixed Data.Foldable Data.Function Data.Functor Data.Functor.Identity Data.IORef Data.Int Data.Ix Data.List Data.Maybe Data.Monoid Data.Ord Data.Proxy Data.Ratio Data.STRef Data.STRef.Lazy Data.STRef.Strict Data.String Data.Traversable Data.Tuple Data.Type.Bool Data.Type.Coercion Data.Type.Equality Data.Typeable Data.Typeable.Internal Data.Unique Data.Version Data.Void Data.Word Debug.Trace Foreign Foreign.C Foreign.C.Error Foreign.C.String Foreign.C.Types Foreign.Concurrent Foreign.ForeignPtr Foreign.ForeignPtr.Safe Foreign.ForeignPtr.Unsafe Foreign.Marshal Foreign.Marshal.Alloc Foreign.Marshal.Array Foreign.Marshal.Error Foreign.Marshal.Pool Foreign.Marshal.Safe Foreign.Marshal.Unsafe Foreign.Marshal.Utils Foreign.Ptr Foreign.Safe Foreign.StablePtr Foreign.Storable GHC.Arr GHC.Base GHC.Char GHC.Conc GHC.Conc.IO GHC.Conc.Signal GHC.Conc.Sync GHC.ConsoleHandler GHC.Constants GHC.Desugar GHC.Enum GHC.Environment GHC.Err GHC.Exception GHC.Exts GHC.Fingerprint GHC.Fingerprint.Type GHC.Float GHC.Float.ConversionUtils GHC.Float.RealFracMethods GHC.Foreign GHC.ForeignPtr GHC.GHCi GHC.Generics GHC.IO GHC.IO.Buffer GHC.IO.BufferedIO GHC.IO.Device GHC.IO.Encoding GHC.IO.Encoding.CodePage GHC.IO.Encoding.Failure GHC.IO.Encoding.Iconv GHC.IO.Encoding.Latin1 GHC.IO.Encoding.Types GHC.IO.Encoding.UTF16 GHC.IO.Encoding.UTF32 GHC.IO.Encoding.UTF8 GHC.IO.Exception GHC.IO.FD GHC.IO.Handle GHC.IO.Handle.FD GHC.IO.Handle.Internals GHC.IO.Handle.Text GHC.IO.Handle.Types GHC.IO.IOMode GHC.IOArray GHC.IORef GHC.IP GHC.Int GHC.List GHC.MVar GHC.Natural GHC.Num GHC.OldList GHC.PArr GHC.Pack GHC.Profiling GHC.Ptr GHC.Read GHC.Real GHC.RTS.Flags GHC.ST GHC.StaticPtr GHC.STRef GHC.Show GHC.Stable GHC.Stack GHC.Stats GHC.Storable GHC.TopHandler GHC.TypeLits GHC.Unicode GHC.Weak GHC.Word Numeric Numeric.Natural Prelude System.CPUTime System.Console.GetOpt System.Environment System.Exit System.IO System.IO.Error System.IO.Unsafe System.Info System.Mem System.Mem.StableName System.Mem.Weak System.Posix.Internals System.Posix.Types System.Timeout Text.ParserCombinators.ReadP Text.ParserCombinators.ReadPrec Text.Printf Text.Read Text.Read.Lex Text.Show Text.Show.Functions Unsafe.Coerce GHC.Event hidden-modules: Control.Monad.ST.Imp Control.Monad.ST.Lazy.Imp Data.OldList Foreign.ForeignPtr.Imp System.Environment.ExecutablePath GHC.Event.Arr GHC.Event.Array GHC.Event.Clock GHC.Event.Control GHC.Event.EPoll GHC.Event.IntTable GHC.Event.Internal GHC.Event.KQueue GHC.Event.Manager GHC.Event.PSQ GHC.Event.Poll GHC.Event.Thread GHC.Event.TimerManager GHC.Event.Unique trusted: False import-dirs: /opt/ghc/7.10.1/lib/ghc-7.10.1/base_I5BErHzyOm07EBNpKBEeUv library-dirs: /opt/ghc/7.10.1/lib/ghc-7.10.1/base_I5BErHzyOm07EBNpKBEeUv data-dir: /opt/ghc/7.10.1/share/x86_64-linux-ghc-7.10.1/base-4.8.0.0 hs-libraries: HSbase-4.8.0.0-I5BErHzyOm07EBNpKBEeUv include-dirs: /opt/ghc/7.10.1/lib/ghc-7.10.1/base_I5BErHzyOm07EBNpKBEeUv/include includes: HsBase.h depends: builtin_rts ghc-prim-0.4.0.0-7c945cc0c41d3b7b70f3edd125671166 integer-gmp-1.0.0.0-3c947e5fb6dca14804d9b2793c521b67 haddock-interfaces: /opt/ghc/7.10.1/share/doc/ghc/html/libraries/base-4.8.0.0/base.haddock haddock-html: /opt/ghc/7.10.1/share/doc/ghc/html/libraries/base-4.8.0.0 pkgroot: "/opt/ghc/7.10.1/lib/ghc-7.10.1" --- name: integer-gmp version: 1.0.0.0 id: integer-gmp-1.0.0.0-3c947e5fb6dca14804d9b2793c521b67 key: integ_2aU3IZNMF9a7mQ0OzsZ0dS license: BSD3 maintainer: hvr@gnu.org synopsis: Integer library based on GMP category: Numeric, Algebra author: Herbert Valerio Riedel exposed: True exposed-modules: GHC.Integer GHC.Integer.Logarithms GHC.Integer.Logarithms.Internals GHC.Integer.GMP.Internals hidden-modules: GHC.Integer.Type trusted: False import-dirs: /opt/ghc/7.10.1/lib/ghc-7.10.1/integ_2aU3IZNMF9a7mQ0OzsZ0dS library-dirs: /opt/ghc/7.10.1/lib/ghc-7.10.1/integ_2aU3IZNMF9a7mQ0OzsZ0dS data-dir: /opt/ghc/7.10.1/share/x86_64-linux-ghc-7.10.1/integer-gmp-1.0.0.0 hs-libraries: HSinteger-gmp-1.0.0.0-2aU3IZNMF9a7mQ0OzsZ0dS extra-libraries: gmp include-dirs: /opt/ghc/7.10.1/lib/ghc-7.10.1/integ_2aU3IZNMF9a7mQ0OzsZ0dS/include depends: ghc-prim-0.4.0.0-7c945cc0c41d3b7b70f3edd125671166 haddock-interfaces: /opt/ghc/7.10.1/share/doc/ghc/html/libraries/integer-gmp-1.0.0.0/integer-gmp.haddock haddock-html: /opt/ghc/7.10.1/share/doc/ghc/html/libraries/integer-gmp-1.0.0.0 pkgroot: "/opt/ghc/7.10.1/lib/ghc-7.10.1" --- name: ghc-prim version: 0.4.0.0 id: ghc-prim-0.4.0.0-7c945cc0c41d3b7b70f3edd125671166 key: ghcpr_8TmvWUcS1U1IKHT0levwg3 license: BSD3 maintainer: libraries@haskell.org synopsis: GHC primitives description: GHC primitives. category: GHC exposed: True exposed-modules: GHC.CString GHC.Classes GHC.Debug GHC.IntWord64 GHC.Magic GHC.PrimopWrappers GHC.Tuple GHC.Types GHC.Prim trusted: False import-dirs: /opt/ghc/7.10.1/lib/ghc-7.10.1/ghcpr_8TmvWUcS1U1IKHT0levwg3 library-dirs: /opt/ghc/7.10.1/lib/ghc-7.10.1/ghcpr_8TmvWUcS1U1IKHT0levwg3 data-dir: /opt/ghc/7.10.1/share/x86_64-linux-ghc-7.10.1/ghc-prim-0.4.0.0 hs-libraries: HSghc-prim-0.4.0.0-8TmvWUcS1U1IKHT0levwg3 depends: builtin_rts haddock-interfaces: /opt/ghc/7.10.1/share/doc/ghc/html/libraries/ghc-prim-0.4.0.0/ghc-prim.haddock haddock-html: /opt/ghc/7.10.1/share/doc/ghc/html/libraries/ghc-prim-0.4.0.0 pkgroot: "/opt/ghc/7.10.1/lib/ghc-7.10.1" --- name: rts version: 1.0 id: builtin_rts key: rts license: BSD3 maintainer: glasgow-haskell-users@haskell.org exposed: True trusted: False library-dirs: /opt/ghc/7.10.1/lib/ghc-7.10.1/rts hs-libraries: HSrts Cffi extra-libraries: m rt dl include-dirs: /opt/ghc/7.10.1/lib/ghc-7.10.1/include includes: Stg.h ld-options: "-Wl,-u,ghczmprim_GHCziTypes_Izh_static_info" "-Wl,-u,ghczmprim_GHCziTypes_Czh_static_info" "-Wl,-u,ghczmprim_GHCziTypes_Fzh_static_info" "-Wl,-u,ghczmprim_GHCziTypes_Dzh_static_info" "-Wl,-u,base_GHCziPtr_Ptr_static_info" "-Wl,-u,ghczmprim_GHCziTypes_Wzh_static_info" "-Wl,-u,base_GHCziInt_I8zh_static_info" "-Wl,-u,base_GHCziInt_I16zh_static_info" "-Wl,-u,base_GHCziInt_I32zh_static_info" "-Wl,-u,base_GHCziInt_I64zh_static_info" "-Wl,-u,base_GHCziWord_W8zh_static_info" "-Wl,-u,base_GHCziWord_W16zh_static_info" "-Wl,-u,base_GHCziWord_W32zh_static_info" "-Wl,-u,base_GHCziWord_W64zh_static_info" "-Wl,-u,base_GHCziStable_StablePtr_static_info" "-Wl,-u,ghczmprim_GHCziTypes_Izh_con_info" "-Wl,-u,ghczmprim_GHCziTypes_Czh_con_info" "-Wl,-u,ghczmprim_GHCziTypes_Fzh_con_info" "-Wl,-u,ghczmprim_GHCziTypes_Dzh_con_info" "-Wl,-u,base_GHCziPtr_Ptr_con_info" "-Wl,-u,base_GHCziPtr_FunPtr_con_info" "-Wl,-u,base_GHCziStable_StablePtr_con_info" "-Wl,-u,ghczmprim_GHCziTypes_False_closure" "-Wl,-u,ghczmprim_GHCziTypes_True_closure" "-Wl,-u,base_GHCziPack_unpackCString_closure" "-Wl,-u,base_GHCziIOziException_stackOverflow_closure" "-Wl,-u,base_GHCziIOziException_heapOverflow_closure" "-Wl,-u,base_ControlziExceptionziBase_nonTermination_closure" "-Wl,-u,base_GHCziIOziException_blockedIndefinitelyOnMVar_closure" "-Wl,-u,base_GHCziIOziException_blockedIndefinitelyOnSTM_closure" "-Wl,-u,base_GHCziIOziException_allocationLimitExceeded_closure" "-Wl,-u,base_ControlziExceptionziBase_nestedAtomically_closure" "-Wl,-u,base_GHCziEventziThread_blockedOnBadFD_closure" "-Wl,-u,base_GHCziWeak_runFinalizzerBatch_closure" "-Wl,-u,base_GHCziTopHandler_flushStdHandles_closure" "-Wl,-u,base_GHCziTopHandler_runIO_closure" "-Wl,-u,base_GHCziTopHandler_runNonIO_closure" "-Wl,-u,base_GHCziConcziIO_ensureIOManagerIsRunning_closure" "-Wl,-u,base_GHCziConcziIO_ioManagerCapabilitiesChanged_closure" "-Wl,-u,base_GHCziConcziSync_runSparks_closure" "-Wl,-u,base_GHCziConcziSignal_runHandlersPtr_closure" pkgroot: "/opt/ghc/7.10.1/lib/ghc-7.10.1" stack-1.9.3.1/test/package-dump/ghc-7.8.4-osx.txt0000644000000000000000000000625713015755774017310 0ustar0000000000000000name: hmatrix version: 0.16.1.5 id: hmatrix-0.16.1.5-12d5d21f26aa98774cdd8edbc343fbfe license: BSD3 copyright: maintainer: Alberto Ruiz stability: provisional homepage: https://github.com/albertoruiz/hmatrix package-url: synopsis: Numeric Linear Algebra description: Linear algebra based on BLAS and LAPACK. . The package is organized as follows: . ["Numeric.LinearAlgebra.HMatrix"] Starting point and recommended import module for most applications. . ["Numeric.LinearAlgebra.Static"] Experimental alternative interface. . ["Numeric.LinearAlgebra.Devel"] Tools for extending the library. . (Other modules are exposed with hidden documentation for backwards compatibility.) . Code examples: category: Math author: Alberto Ruiz exposed: True exposed-modules: Data.Packed Data.Packed.Vector Data.Packed.Matrix Data.Packed.Foreign Data.Packed.ST Data.Packed.Development Numeric.LinearAlgebra Numeric.LinearAlgebra.LAPACK Numeric.LinearAlgebra.Algorithms Numeric.Container Numeric.LinearAlgebra.Util Numeric.LinearAlgebra.Devel Numeric.LinearAlgebra.Data Numeric.LinearAlgebra.HMatrix Numeric.LinearAlgebra.Static hidden-modules: Data.Packed.Internal Data.Packed.Internal.Common Data.Packed.Internal.Signatures Data.Packed.Internal.Vector Data.Packed.Internal.Matrix Data.Packed.IO Numeric.Chain Numeric.Vectorized Numeric.Vector Numeric.Matrix Data.Packed.Internal.Numeric Data.Packed.Numeric Numeric.LinearAlgebra.Util.Convolution Numeric.LinearAlgebra.Util.CG Numeric.LinearAlgebra.Random Numeric.Conversion Numeric.Sparse Numeric.LinearAlgebra.Static.Internal trusted: False import-dirs: /Users/alexbiehl/.stack/snapshots/x86_64-osx/lts-2.13/7.8.4/lib/x86_64-osx-ghc-7.8.4/hmatrix-0.16.1.5 library-dirs: /Users/alexbiehl/.stack/snapshots/x86_64-osx/lts-2.13/7.8.4/lib/x86_64-osx-ghc-7.8.4/hmatrix-0.16.1.5 /opt/local/lib/ /usr/local/lib/ "C:/Program Files/Example/" hs-libraries: HShmatrix-0.16.1.5 extra-libraries: blas lapack extra-ghci-libraries: include-dirs: /opt/local/include/ /usr/local/include/ includes: depends: array-0.5.0.0-470385a50d2b78598af85cfe9d988e1b base-4.7.0.2-918c7ac27f65a87103264a9f51652d63 binary-0.7.1.0-108d06eea2ef05e517f9c1facf10f63c bytestring-0.10.4.0-78bc8f2c724c765c78c004a84acf6cc3 deepseq-1.3.0.2-0ddc77716bd2515426e1ba39f6788a4f random-1.1-822c19b7507b6ac1aaa4c66731e775ae split-0.2.2-34cfb851cc3784e22bfae7a7bddda9c5 storable-complex-0.2.2-e962c368d58acc1f5b41d41edc93da72 vector-0.10.12.3-f4222db607fd5fdd7545d3e82419b307 hugs-options: cc-options: ld-options: framework-dirs: frameworks: Accelerate haddock-interfaces: /Users/alexbiehl/.stack/snapshots/x86_64-osx/lts-2.13/7.8.4/doc/html/hmatrix.haddock haddock-html: /Users/alexbiehl/.stack/snapshots/x86_64-osx/lts-2.13/7.8.4/doc/html stack-1.9.3.1/test/package-dump/ghc-7.8.txt0000644000000000000000000020004412535613373016317 0ustar0000000000000000name: haskell2010 version: 1.1.2.0 id: haskell2010-1.1.2.0-05c8dd51009e08c6371c82972d40f55a license: BSD3 copyright: maintainer: libraries@haskell.org stability: homepage: http://www.haskell.org/onlinereport/haskell2010/ package-url: synopsis: Compatibility with Haskell 2010 description: This package provides exactly the library modules defined by the . category: Haskell2010, Prelude author: exposed: False exposed-modules: Prelude Control.Monad Data.Array Data.Bits Data.Char Data.Complex Data.Int Data.Ix Data.List Data.Maybe Data.Ratio Data.Word Foreign Foreign.C Foreign.C.Error Foreign.C.String Foreign.C.Types Foreign.ForeignPtr Foreign.Marshal Foreign.Marshal.Alloc Foreign.Marshal.Array Foreign.Marshal.Error Foreign.Marshal.Utils Foreign.Ptr Foreign.StablePtr Foreign.Storable Numeric System.Environment System.Exit System.IO System.IO.Error hidden-modules: trusted: False import-dirs: /opt/ghc/7.8.4/lib/ghc-7.8.4/haskell2010-1.1.2.0 library-dirs: /opt/ghc/7.8.4/lib/ghc-7.8.4/haskell2010-1.1.2.0 hs-libraries: HShaskell2010-1.1.2.0 extra-libraries: extra-ghci-libraries: include-dirs: includes: depends: array-0.5.0.0-470385a50d2b78598af85cfe9d988e1b base-4.7.0.2-bfd89587617e381ae01b8dd7b6c7f1c1 ghc-prim-0.3.1.0-a24f9c14c632d75b683d0f93283aea37 hugs-options: cc-options: ld-options: framework-dirs: frameworks: haddock-interfaces: /opt/ghc/7.8.4/share/doc/ghc/html/libraries/haskell2010-1.1.2.0/haskell2010.haddock haddock-html: /opt/ghc/7.8.4/share/doc/ghc/html/libraries/haskell2010-1.1.2.0 pkgroot: "/opt/ghc/7.8.4/lib/ghc-7.8.4" --- name: haskell98 version: 2.0.0.3 id: haskell98-2.0.0.3-045e8778b656db76e2c729405eee707b license: BSD3 copyright: maintainer: libraries@haskell.org stability: homepage: http://www.haskell.org/definition/ package-url: synopsis: Compatibility with Haskell 98 description: This package provides compatibility with the modules of Haskell 98 and the FFI addendum, by means of wrappers around modules from the base package (which in many cases have additional features). However "Prelude", "Numeric" and "Foreign" are provided directly by the @base@ package. category: Haskell98, Prelude author: exposed: False exposed-modules: Prelude Array CPUTime Char Complex Directory IO Ix List Locale Maybe Monad Numeric Random Ratio System Time Bits CError CForeign CString CTypes ForeignPtr Int MarshalAlloc MarshalArray MarshalError MarshalUtils Ptr StablePtr Storable Word hidden-modules: trusted: False import-dirs: /opt/ghc/7.8.4/lib/ghc-7.8.4/haskell98-2.0.0.3 library-dirs: /opt/ghc/7.8.4/lib/ghc-7.8.4/haskell98-2.0.0.3 hs-libraries: HShaskell98-2.0.0.3 extra-libraries: extra-ghci-libraries: include-dirs: includes: depends: array-0.5.0.0-470385a50d2b78598af85cfe9d988e1b base-4.7.0.2-bfd89587617e381ae01b8dd7b6c7f1c1 directory-1.2.1.0-07cd1f59e3c6cac5e3e180019c59a115 old-locale-1.0.0.6-50b0125c49f76af85dc7aa22975cdc34 old-time-1.1.0.2-e3f776e97c1a6ff1770b04943a7ef7c6 process-1.2.0.0-06c3215a79834ce4886ae686a0f81122 time-1.4.2-9b3076800c33f8382c38628f35717951 hugs-options: cc-options: ld-options: framework-dirs: frameworks: haddock-interfaces: /opt/ghc/7.8.4/share/doc/ghc/html/libraries/haskell98-2.0.0.3/haskell98.haddock haddock-html: /opt/ghc/7.8.4/share/doc/ghc/html/libraries/haskell98-2.0.0.3 pkgroot: "/opt/ghc/7.8.4/lib/ghc-7.8.4" --- name: old-time version: 1.1.0.2 id: old-time-1.1.0.2-e3f776e97c1a6ff1770b04943a7ef7c6 license: BSD3 copyright: maintainer: libraries@haskell.org stability: homepage: package-url: synopsis: Time library description: This package provides the old time library. . For new projects, the newer is recommended. category: System author: exposed: True exposed-modules: System.Time hidden-modules: trusted: False import-dirs: /opt/ghc/7.8.4/lib/ghc-7.8.4/old-time-1.1.0.2 library-dirs: /opt/ghc/7.8.4/lib/ghc-7.8.4/old-time-1.1.0.2 hs-libraries: HSold-time-1.1.0.2 extra-libraries: extra-ghci-libraries: include-dirs: /opt/ghc/7.8.4/lib/ghc-7.8.4/old-time-1.1.0.2/include includes: HsTime.h depends: base-4.7.0.2-bfd89587617e381ae01b8dd7b6c7f1c1 old-locale-1.0.0.6-50b0125c49f76af85dc7aa22975cdc34 hugs-options: cc-options: ld-options: framework-dirs: frameworks: haddock-interfaces: /opt/ghc/7.8.4/share/doc/ghc/html/libraries/old-time-1.1.0.2/old-time.haddock haddock-html: /opt/ghc/7.8.4/share/doc/ghc/html/libraries/old-time-1.1.0.2 pkgroot: "/opt/ghc/7.8.4/lib/ghc-7.8.4" --- name: ghc version: 7.8.4 id: ghc-7.8.4-6c4818bc66adb23509058069f781d99a license: BSD3 copyright: maintainer: glasgow-haskell-users@haskell.org stability: homepage: http://www.haskell.org/ghc/ package-url: synopsis: The GHC API description: GHC's functionality can be useful for more things than just compiling Haskell programs. Important use cases are programs that analyse (and perhaps transform) Haskell code. Others include loading Haskell code dynamically in a GHCi-like manner. For this reason, a lot of GHC's functionality is made available through this package. category: Development author: The GHC Team exposed: False exposed-modules: Avail BasicTypes ConLike DataCon PatSyn Demand Exception GhcMonad Hooks Id IdInfo Literal Llvm Llvm.AbsSyn Llvm.MetaData Llvm.PpLlvm Llvm.Types LlvmCodeGen LlvmCodeGen.Base LlvmCodeGen.CodeGen LlvmCodeGen.Data LlvmCodeGen.Ppr LlvmCodeGen.Regs LlvmMangler MkId Module Name NameEnv NameSet OccName RdrName SrcLoc UniqSupply Unique Var VarEnv VarSet BlockId CLabel Cmm CmmBuildInfoTables CmmPipeline CmmCallConv CmmCommonBlockElim CmmContFlowOpt CmmExpr CmmInfo CmmLex CmmLint CmmLive CmmMachOp CmmNode CmmOpt CmmParse CmmProcPoint CmmRewriteAssignments CmmSink CmmType CmmUtils CmmLayoutStack MkGraph PprBase PprC PprCmm PprCmmDecl PprCmmExpr Bitmap CodeGen.Platform CodeGen.Platform.ARM CodeGen.Platform.NoRegs CodeGen.Platform.PPC CodeGen.Platform.PPC_Darwin CodeGen.Platform.SPARC CodeGen.Platform.X86 CodeGen.Platform.X86_64 CgUtils StgCmm StgCmmBind StgCmmClosure StgCmmCon StgCmmEnv StgCmmExpr StgCmmForeign StgCmmHeap StgCmmHpc StgCmmArgRep StgCmmLayout StgCmmMonad StgCmmPrim StgCmmProf StgCmmTicky StgCmmUtils StgCmmExtCode SMRep CoreArity CoreFVs CoreLint CorePrep CoreSubst CoreSyn TrieMap CoreTidy CoreUnfold CoreUtils ExternalCore MkCore MkExternalCore PprCore PprExternalCore Check Coverage Desugar DsArrows DsBinds DsCCall DsExpr DsForeign DsGRHSs DsListComp DsMonad DsUtils Match MatchCon MatchLit HsBinds HsDecls HsDoc HsExpr HsImpExp HsLit HsPat HsSyn HsTypes HsUtils BinIface BuildTyCl IfaceEnv IfaceSyn IfaceType LoadIface MkIface TcIface FlagChecker Annotations BreakArray CmdLineParser CodeOutput Config Constants DriverMkDepend DriverPhases PipelineMonad DriverPipeline DynFlags ErrUtils Finder GHC GhcMake GhcPlugins DynamicLoading HeaderInfo HscMain HscStats HscTypes InteractiveEval InteractiveEvalTypes PackageConfig Packages PlatformConstants PprTyThing StaticFlags SysTools TidyPgm Ctype HaddockUtils LexCore Lexer OptCoercion Parser ParserCore ParserCoreUtils RdrHsSyn ForeignCall PrelInfo PrelNames PrelRules PrimOp TysPrim TysWiredIn CostCentre ProfInit SCCfinal RnBinds RnEnv RnExpr RnHsDoc RnNames RnPat RnSource RnSplice RnTypes CoreMonad CSE FloatIn FloatOut LiberateCase OccurAnal SAT SetLevels SimplCore SimplEnv SimplMonad SimplUtils Simplify SimplStg StgStats UnariseStg Rules SpecConstr Specialise CoreToStg StgLint StgSyn DmdAnal WorkWrap WwLib FamInst Inst TcAnnotations TcArrows TcBinds TcClassDcl TcDefaults TcDeriv TcEnv TcExpr TcForeign TcGenDeriv TcGenGenerics TcHsSyn TcHsType TcInstDcls TcMType TcValidity TcMatches TcPat TcPatSyn TcRnDriver TcRnMonad TcRnTypes TcRules TcSimplify TcErrors TcTyClsDecls TcTyDecls TcType TcEvidence TcUnify TcInteract TcCanonical TcSMonad TcTypeNats TcSplice Class Coercion FamInstEnv FunDeps InstEnv TyCon CoAxiom Kind Type TypeRep Unify Bag Binary BooleanFormula BufWrite Digraph Encoding FastBool FastFunctions FastMutInt FastString FastTypes Fingerprint FiniteMap GraphBase GraphColor GraphOps GraphPpr IOEnv ListSetOps Maybes MonadUtils OrdList Outputable Pair Panic Pretty Serialized State Stream StringBuffer UniqFM UniqSet Util ExtsCompat46 Vectorise.Builtins.Base Vectorise.Builtins.Initialise Vectorise.Builtins Vectorise.Monad.Base Vectorise.Monad.Naming Vectorise.Monad.Local Vectorise.Monad.Global Vectorise.Monad.InstEnv Vectorise.Monad Vectorise.Utils.Base Vectorise.Utils.Closure Vectorise.Utils.Hoisting Vectorise.Utils.PADict Vectorise.Utils.Poly Vectorise.Utils Vectorise.Generic.Description Vectorise.Generic.PAMethods Vectorise.Generic.PADict Vectorise.Generic.PData Vectorise.Type.Env Vectorise.Type.Type Vectorise.Type.TyConDecl Vectorise.Type.Classify Vectorise.Convert Vectorise.Vect Vectorise.Var Vectorise.Env Vectorise.Exp Vectorise Hoopl.Dataflow Hoopl AsmCodeGen TargetReg NCGMonad Instruction Size Reg RegClass PIC Platform CPrim X86.Regs X86.RegInfo X86.Instr X86.Cond X86.Ppr X86.CodeGen PPC.Regs PPC.RegInfo PPC.Instr PPC.Cond PPC.Ppr PPC.CodeGen SPARC.Base SPARC.Regs SPARC.Imm SPARC.AddrMode SPARC.Cond SPARC.Instr SPARC.Stack SPARC.ShortcutJump SPARC.Ppr SPARC.CodeGen SPARC.CodeGen.Amode SPARC.CodeGen.Base SPARC.CodeGen.CondCode SPARC.CodeGen.Gen32 SPARC.CodeGen.Gen64 SPARC.CodeGen.Sanity SPARC.CodeGen.Expand RegAlloc.Liveness RegAlloc.Graph.Main RegAlloc.Graph.Stats RegAlloc.Graph.ArchBase RegAlloc.Graph.ArchX86 RegAlloc.Graph.Coalesce RegAlloc.Graph.Spill RegAlloc.Graph.SpillClean RegAlloc.Graph.SpillCost RegAlloc.Graph.TrivColorable RegAlloc.Linear.Main RegAlloc.Linear.JoinToTargets RegAlloc.Linear.State RegAlloc.Linear.Stats RegAlloc.Linear.FreeRegs RegAlloc.Linear.StackMap RegAlloc.Linear.Base RegAlloc.Linear.X86.FreeRegs RegAlloc.Linear.X86_64.FreeRegs RegAlloc.Linear.PPC.FreeRegs RegAlloc.Linear.SPARC.FreeRegs DsMeta Convert ByteCodeAsm ByteCodeGen ByteCodeInstr ByteCodeItbls ByteCodeLink Debugger LibFFI Linker ObjLink RtClosureInspect DebuggerUtils hidden-modules: trusted: False import-dirs: /opt/ghc/7.8.4/lib/ghc-7.8.4/ghc-7.8.4 library-dirs: /opt/ghc/7.8.4/lib/ghc-7.8.4/ghc-7.8.4 hs-libraries: HSghc-7.8.4 extra-libraries: extra-ghci-libraries: include-dirs: /opt/ghc/7.8.4/lib/ghc-7.8.4/ghc-7.8.4/include includes: depends: Cabal-1.18.1.5-6478013104bde01737bfd67d34bbee0a array-0.5.0.0-470385a50d2b78598af85cfe9d988e1b base-4.7.0.2-bfd89587617e381ae01b8dd7b6c7f1c1 bin-package-db-0.0.0.0-0f3da03684207f2dc4dce793df1db62e bytestring-0.10.4.0-d6f1d17d717e8652498cab8269a0acd5 containers-0.5.5.1-d4bd887fb97aa3a46cbadc13709b7653 directory-1.2.1.0-07cd1f59e3c6cac5e3e180019c59a115 filepath-1.3.0.2-25a474a9272ae6260626ce0d70ad1cab hoopl-3.10.0.1-267659e4b5b51c3d2e02f2a6d6f46936 hpc-0.6.0.1-cca17f12dab542e09c423a74a4590c5d process-1.2.0.0-06c3215a79834ce4886ae686a0f81122 template-haskell-2.9.0.0-6d27c2b362b15abb1822f2f34b9ae7f9 time-1.4.2-9b3076800c33f8382c38628f35717951 transformers-0.3.0.0-6458c21515cab7c1cf21e53141557a1c unix-2.7.0.1-f8658ba9ec1c4fba8a371a8e0f42ec6c hugs-options: cc-options: ld-options: framework-dirs: frameworks: haddock-interfaces: /opt/ghc/7.8.4/share/doc/ghc/html/libraries/ghc-7.8.4/ghc.haddock haddock-html: /opt/ghc/7.8.4/share/doc/ghc/html/libraries/ghc-7.8.4 pkgroot: "/opt/ghc/7.8.4/lib/ghc-7.8.4" --- name: haskeline version: 0.7.1.2 id: haskeline-0.7.1.2-2dd2f2fb537352f5367ae77fe47ab211 license: BSD3 copyright: (c) Judah Jacobson maintainer: Judah Jacobson stability: Experimental homepage: http://trac.haskell.org/haskeline package-url: synopsis: A command-line interface for user input, written in Haskell. description: Haskeline provides a user interface for line input in command-line programs. This library is similar in purpose to readline, but since it is written in Haskell it is (hopefully) more easily used in other Haskell programs. . Haskeline runs both on POSIX-compatible systems and on Windows. category: User Interfaces author: Judah Jacobson exposed: True exposed-modules: System.Console.Haskeline System.Console.Haskeline.Completion System.Console.Haskeline.MonadException System.Console.Haskeline.History System.Console.Haskeline.IO hidden-modules: System.Console.Haskeline.Backend System.Console.Haskeline.Backend.WCWidth System.Console.Haskeline.Command System.Console.Haskeline.Command.Completion System.Console.Haskeline.Command.History System.Console.Haskeline.Command.KillRing System.Console.Haskeline.Directory System.Console.Haskeline.Emacs System.Console.Haskeline.InputT System.Console.Haskeline.Key System.Console.Haskeline.LineState System.Console.Haskeline.Monads System.Console.Haskeline.Prefs System.Console.Haskeline.RunCommand System.Console.Haskeline.Term System.Console.Haskeline.Command.Undo System.Console.Haskeline.Vi System.Console.Haskeline.Recover System.Console.Haskeline.Backend.Posix System.Console.Haskeline.Backend.Posix.Encoder System.Console.Haskeline.Backend.DumbTerm System.Console.Haskeline.Backend.Terminfo trusted: False import-dirs: /opt/ghc/7.8.4/lib/ghc-7.8.4/haskeline-0.7.1.2 library-dirs: /opt/ghc/7.8.4/lib/ghc-7.8.4/haskeline-0.7.1.2 hs-libraries: HShaskeline-0.7.1.2 extra-libraries: extra-ghci-libraries: include-dirs: includes: depends: base-4.7.0.2-bfd89587617e381ae01b8dd7b6c7f1c1 bytestring-0.10.4.0-d6f1d17d717e8652498cab8269a0acd5 containers-0.5.5.1-d4bd887fb97aa3a46cbadc13709b7653 directory-1.2.1.0-07cd1f59e3c6cac5e3e180019c59a115 filepath-1.3.0.2-25a474a9272ae6260626ce0d70ad1cab terminfo-0.4.0.0-c1d02a7210b0d1bc250d87463b38b8d1 transformers-0.3.0.0-6458c21515cab7c1cf21e53141557a1c unix-2.7.0.1-f8658ba9ec1c4fba8a371a8e0f42ec6c hugs-options: cc-options: ld-options: framework-dirs: frameworks: haddock-interfaces: /opt/ghc/7.8.4/share/doc/ghc/html/libraries/haskeline-0.7.1.2/haskeline.haddock haddock-html: /opt/ghc/7.8.4/share/doc/ghc/html/libraries/haskeline-0.7.1.2 pkgroot: "/opt/ghc/7.8.4/lib/ghc-7.8.4" --- name: terminfo version: 0.4.0.0 id: terminfo-0.4.0.0-c1d02a7210b0d1bc250d87463b38b8d1 license: BSD3 copyright: (c) Judah Jacobson maintainer: Judah Jacobson stability: Stable homepage: https://github.com/judah/terminfo package-url: synopsis: Haskell bindings to the terminfo library. description: This library provides an interface to the terminfo database (via bindings to the curses library). allows POSIX systems to interact with a variety of terminals using a standard set of capabilities. category: User Interfaces author: Judah Jacobson exposed: True exposed-modules: System.Console.Terminfo System.Console.Terminfo.Base System.Console.Terminfo.Cursor System.Console.Terminfo.Color System.Console.Terminfo.Edit System.Console.Terminfo.Effects System.Console.Terminfo.Keys hidden-modules: trusted: False import-dirs: /opt/ghc/7.8.4/lib/ghc-7.8.4/terminfo-0.4.0.0 library-dirs: /opt/ghc/7.8.4/lib/ghc-7.8.4/terminfo-0.4.0.0 hs-libraries: HSterminfo-0.4.0.0 extra-libraries: tinfo extra-ghci-libraries: include-dirs: includes: ncurses.h term.h depends: base-4.7.0.2-bfd89587617e381ae01b8dd7b6c7f1c1 hugs-options: cc-options: ld-options: framework-dirs: frameworks: haddock-interfaces: /opt/ghc/7.8.4/share/doc/ghc/html/libraries/terminfo-0.4.0.0/terminfo.haddock haddock-html: /opt/ghc/7.8.4/share/doc/ghc/html/libraries/terminfo-0.4.0.0 pkgroot: "/opt/ghc/7.8.4/lib/ghc-7.8.4" --- name: xhtml version: 3000.2.1 id: xhtml-3000.2.1-6a3ed472b07e58fe29db22a5bc2bdb06 license: BSD3 copyright: Bjorn Bringert 2004-2006, Andy Gill and the Oregon Graduate Institute of Science and Technology, 1999-2001 maintainer: Chris Dornan stability: Stable homepage: https://github.com/haskell/xhtml package-url: synopsis: An XHTML combinator library description: This package provides combinators for producing XHTML 1.0, including the Strict, Transitional and Frameset variants. category: Web, XML, Pretty Printer author: Bjorn Bringert exposed: True exposed-modules: Text.XHtml Text.XHtml.Frameset Text.XHtml.Strict Text.XHtml.Transitional Text.XHtml.Debug Text.XHtml.Table hidden-modules: Text.XHtml.Strict.Attributes Text.XHtml.Strict.Elements Text.XHtml.Frameset.Attributes Text.XHtml.Frameset.Elements Text.XHtml.Transitional.Attributes Text.XHtml.Transitional.Elements Text.XHtml.BlockTable Text.XHtml.Extras Text.XHtml.Internals trusted: False import-dirs: /opt/ghc/7.8.4/lib/ghc-7.8.4/xhtml-3000.2.1 library-dirs: /opt/ghc/7.8.4/lib/ghc-7.8.4/xhtml-3000.2.1 hs-libraries: HSxhtml-3000.2.1 extra-libraries: extra-ghci-libraries: include-dirs: includes: depends: base-4.7.0.2-bfd89587617e381ae01b8dd7b6c7f1c1 hugs-options: cc-options: ld-options: framework-dirs: frameworks: haddock-interfaces: /opt/ghc/7.8.4/share/doc/ghc/html/libraries/xhtml-3000.2.1/xhtml.haddock haddock-html: /opt/ghc/7.8.4/share/doc/ghc/html/libraries/xhtml-3000.2.1 pkgroot: "/opt/ghc/7.8.4/lib/ghc-7.8.4" --- name: transformers version: 0.3.0.0 id: transformers-0.3.0.0-6458c21515cab7c1cf21e53141557a1c license: BSD3 copyright: maintainer: Ross Paterson stability: homepage: package-url: synopsis: Concrete functor and monad transformers description: A portable library of functor and monad transformers, inspired by the paper \"Functional Programming with Overloading and Higher-Order Polymorphism\", by Mark P Jones, in /Advanced School of Functional Programming/, 1995 (). . This package contains: . * the monad transformer class (in "Control.Monad.Trans.Class") . * concrete functor and monad transformers, each with associated operations and functions to lift operations associated with other transformers. . It can be used on its own in portable Haskell code, or with the monad classes in the @mtl@ or @monads-tf@ packages, which automatically lift operations introduced by monad transformers through other transformers. category: Control author: Andy Gill, Ross Paterson exposed: True exposed-modules: Control.Applicative.Backwards Control.Applicative.Lift Control.Monad.IO.Class Control.Monad.Trans.Class Control.Monad.Trans.Cont Control.Monad.Trans.Error Control.Monad.Trans.Identity Control.Monad.Trans.List Control.Monad.Trans.Maybe Control.Monad.Trans.Reader Control.Monad.Trans.RWS Control.Monad.Trans.RWS.Lazy Control.Monad.Trans.RWS.Strict Control.Monad.Trans.State Control.Monad.Trans.State.Lazy Control.Monad.Trans.State.Strict Control.Monad.Trans.Writer Control.Monad.Trans.Writer.Lazy Control.Monad.Trans.Writer.Strict Data.Functor.Compose Data.Functor.Constant Data.Functor.Identity Data.Functor.Product Data.Functor.Reverse hidden-modules: trusted: False import-dirs: /opt/ghc/7.8.4/lib/ghc-7.8.4/transformers-0.3.0.0 library-dirs: /opt/ghc/7.8.4/lib/ghc-7.8.4/transformers-0.3.0.0 hs-libraries: HStransformers-0.3.0.0 extra-libraries: extra-ghci-libraries: include-dirs: includes: depends: base-4.7.0.2-bfd89587617e381ae01b8dd7b6c7f1c1 hugs-options: cc-options: ld-options: framework-dirs: frameworks: haddock-interfaces: /opt/ghc/7.8.4/share/doc/ghc/html/libraries/transformers-0.3.0.0/transformers.haddock haddock-html: /opt/ghc/7.8.4/share/doc/ghc/html/libraries/transformers-0.3.0.0 pkgroot: "/opt/ghc/7.8.4/lib/ghc-7.8.4" --- name: hoopl version: 3.10.0.1 id: hoopl-3.10.0.1-267659e4b5b51c3d2e02f2a6d6f46936 license: BSD3 copyright: maintainer: nr@cs.tufts.edu stability: homepage: http://ghc.cs.tufts.edu/hoopl/ package-url: synopsis: A library to support dataflow analysis and optimization description: Higher-order optimization library . See /Norman Ramsey, Joao Dias, and Simon Peyton Jones./ /(2010)/ for more details. category: Compilers/Interpreters author: Norman Ramsey, Joao Dias, Simon Marlow and Simon Peyton Jones exposed: True exposed-modules: Compiler.Hoopl Compiler.Hoopl.Internals Compiler.Hoopl.Wrappers Compiler.Hoopl.Passes.Dominator Compiler.Hoopl.Passes.DList hidden-modules: Compiler.Hoopl.Checkpoint Compiler.Hoopl.Collections Compiler.Hoopl.Combinators Compiler.Hoopl.Dataflow Compiler.Hoopl.Debug Compiler.Hoopl.Block Compiler.Hoopl.Graph Compiler.Hoopl.Label Compiler.Hoopl.MkGraph Compiler.Hoopl.Fuel Compiler.Hoopl.Pointed Compiler.Hoopl.Shape Compiler.Hoopl.Show Compiler.Hoopl.Unique Compiler.Hoopl.XUtil trusted: False import-dirs: /opt/ghc/7.8.4/lib/ghc-7.8.4/hoopl-3.10.0.1 library-dirs: /opt/ghc/7.8.4/lib/ghc-7.8.4/hoopl-3.10.0.1 hs-libraries: HShoopl-3.10.0.1 extra-libraries: extra-ghci-libraries: include-dirs: includes: depends: base-4.7.0.2-bfd89587617e381ae01b8dd7b6c7f1c1 containers-0.5.5.1-d4bd887fb97aa3a46cbadc13709b7653 hugs-options: cc-options: ld-options: framework-dirs: frameworks: haddock-interfaces: /opt/ghc/7.8.4/share/doc/ghc/html/libraries/hoopl-3.10.0.1/hoopl.haddock haddock-html: /opt/ghc/7.8.4/share/doc/ghc/html/libraries/hoopl-3.10.0.1 pkgroot: "/opt/ghc/7.8.4/lib/ghc-7.8.4" --- name: bin-package-db version: 0.0.0.0 id: bin-package-db-0.0.0.0-0f3da03684207f2dc4dce793df1db62e license: BSD3 copyright: maintainer: ghc-devs@haskell.org stability: homepage: package-url: synopsis: A binary format for the package database description: category: author: exposed: True exposed-modules: Distribution.InstalledPackageInfo.Binary hidden-modules: trusted: False import-dirs: /opt/ghc/7.8.4/lib/ghc-7.8.4/bin-package-db-0.0.0.0 library-dirs: /opt/ghc/7.8.4/lib/ghc-7.8.4/bin-package-db-0.0.0.0 hs-libraries: HSbin-package-db-0.0.0.0 extra-libraries: extra-ghci-libraries: include-dirs: includes: depends: Cabal-1.18.1.5-6478013104bde01737bfd67d34bbee0a base-4.7.0.2-bfd89587617e381ae01b8dd7b6c7f1c1 binary-0.7.1.0-f867dbbb69966feb9f5c4ef7695a70a5 hugs-options: cc-options: ld-options: framework-dirs: frameworks: haddock-interfaces: /opt/ghc/7.8.4/share/doc/ghc/html/libraries/bin-package-db-0.0.0.0/bin-package-db.haddock haddock-html: /opt/ghc/7.8.4/share/doc/ghc/html/libraries/bin-package-db-0.0.0.0 pkgroot: "/opt/ghc/7.8.4/lib/ghc-7.8.4" --- name: binary version: 0.7.1.0 id: binary-0.7.1.0-f867dbbb69966feb9f5c4ef7695a70a5 license: BSD3 copyright: maintainer: Lennart Kolmodin, Don Stewart stability: provisional homepage: https://github.com/kolmodin/binary package-url: synopsis: Binary serialisation for Haskell values using lazy ByteStrings description: Efficient, pure binary serialisation using lazy ByteStrings. Haskell values may be encoded to and from binary formats, written to disk as binary, or sent over the network. The format used can be automatically generated, or you can choose to implement a custom format if needed. Serialisation speeds of over 1 G\/sec have been observed, so this library should be suitable for high performance scenarios. category: Data, Parsing author: Lennart Kolmodin exposed: True exposed-modules: Data.Binary Data.Binary.Put Data.Binary.Get Data.Binary.Get.Internal Data.Binary.Builder Data.Binary.Builder.Internal hidden-modules: Data.Binary.Builder.Base Data.Binary.Class Data.Binary.Generic trusted: False import-dirs: /opt/ghc/7.8.4/lib/ghc-7.8.4/binary-0.7.1.0 library-dirs: /opt/ghc/7.8.4/lib/ghc-7.8.4/binary-0.7.1.0 hs-libraries: HSbinary-0.7.1.0 extra-libraries: extra-ghci-libraries: include-dirs: includes: depends: array-0.5.0.0-470385a50d2b78598af85cfe9d988e1b base-4.7.0.2-bfd89587617e381ae01b8dd7b6c7f1c1 bytestring-0.10.4.0-d6f1d17d717e8652498cab8269a0acd5 containers-0.5.5.1-d4bd887fb97aa3a46cbadc13709b7653 hugs-options: cc-options: ld-options: framework-dirs: frameworks: haddock-interfaces: /opt/ghc/7.8.4/share/doc/ghc/html/libraries/binary-0.7.1.0/binary.haddock haddock-html: /opt/ghc/7.8.4/share/doc/ghc/html/libraries/binary-0.7.1.0 pkgroot: "/opt/ghc/7.8.4/lib/ghc-7.8.4" --- name: Cabal version: 1.18.1.5 id: Cabal-1.18.1.5-6478013104bde01737bfd67d34bbee0a license: BSD3 copyright: 2003-2006, Isaac Jones 2005-2011, Duncan Coutts maintainer: cabal-devel@haskell.org stability: homepage: http://www.haskell.org/cabal/ package-url: synopsis: A framework for packaging Haskell software description: The Haskell Common Architecture for Building Applications and Libraries: a framework defining a common interface for authors to more easily build their Haskell applications in a portable way. . The Haskell Cabal is part of a larger infrastructure for distributing, organizing, and cataloging Haskell libraries and tools. category: Distribution author: Isaac Jones Duncan Coutts exposed: True exposed-modules: Distribution.Compat.Environment Distribution.Compat.Exception Distribution.Compat.ReadP Distribution.Compiler Distribution.InstalledPackageInfo Distribution.License Distribution.Make Distribution.ModuleName Distribution.Package Distribution.PackageDescription Distribution.PackageDescription.Check Distribution.PackageDescription.Configuration Distribution.PackageDescription.Parse Distribution.PackageDescription.PrettyPrint Distribution.PackageDescription.Utils Distribution.ParseUtils Distribution.ReadE Distribution.Simple Distribution.Simple.Bench Distribution.Simple.Build Distribution.Simple.Build.Macros Distribution.Simple.Build.PathsModule Distribution.Simple.BuildPaths Distribution.Simple.BuildTarget Distribution.Simple.CCompiler Distribution.Simple.Command Distribution.Simple.Compiler Distribution.Simple.Configure Distribution.Simple.GHC Distribution.Simple.Haddock Distribution.Simple.Hpc Distribution.Simple.Hugs Distribution.Simple.Install Distribution.Simple.InstallDirs Distribution.Simple.JHC Distribution.Simple.LHC Distribution.Simple.LocalBuildInfo Distribution.Simple.NHC Distribution.Simple.PackageIndex Distribution.Simple.PreProcess Distribution.Simple.PreProcess.Unlit Distribution.Simple.Program Distribution.Simple.Program.Ar Distribution.Simple.Program.Builtin Distribution.Simple.Program.Db Distribution.Simple.Program.Find Distribution.Simple.Program.GHC Distribution.Simple.Program.HcPkg Distribution.Simple.Program.Hpc Distribution.Simple.Program.Ld Distribution.Simple.Program.Run Distribution.Simple.Program.Script Distribution.Simple.Program.Types Distribution.Simple.Register Distribution.Simple.Setup Distribution.Simple.SrcDist Distribution.Simple.Test Distribution.Simple.UHC Distribution.Simple.UserHooks Distribution.Simple.Utils Distribution.System Distribution.TestSuite Distribution.Text Distribution.Verbosity Distribution.Version Language.Haskell.Extension hidden-modules: Distribution.Compat.CopyFile Distribution.Compat.TempFile Distribution.GetOpt Distribution.Simple.GHC.IPI641 Distribution.Simple.GHC.IPI642 Paths_Cabal trusted: False import-dirs: /opt/ghc/7.8.4/lib/ghc-7.8.4/Cabal-1.18.1.5 library-dirs: /opt/ghc/7.8.4/lib/ghc-7.8.4/Cabal-1.18.1.5 hs-libraries: HSCabal-1.18.1.5 extra-libraries: extra-ghci-libraries: include-dirs: includes: depends: array-0.5.0.0-470385a50d2b78598af85cfe9d988e1b base-4.7.0.2-bfd89587617e381ae01b8dd7b6c7f1c1 bytestring-0.10.4.0-d6f1d17d717e8652498cab8269a0acd5 containers-0.5.5.1-d4bd887fb97aa3a46cbadc13709b7653 deepseq-1.3.0.2-63a1ab91b7017a28bb5d04cb1b5d2d02 directory-1.2.1.0-07cd1f59e3c6cac5e3e180019c59a115 filepath-1.3.0.2-25a474a9272ae6260626ce0d70ad1cab pretty-1.1.1.1-0984f47ffe93ef3983c80b96280f1c3a process-1.2.0.0-06c3215a79834ce4886ae686a0f81122 time-1.4.2-9b3076800c33f8382c38628f35717951 unix-2.7.0.1-f8658ba9ec1c4fba8a371a8e0f42ec6c hugs-options: cc-options: ld-options: framework-dirs: frameworks: haddock-interfaces: /opt/ghc/7.8.4/share/doc/ghc/html/libraries/Cabal-1.18.1.5/Cabal.haddock haddock-html: /opt/ghc/7.8.4/share/doc/ghc/html/libraries/Cabal-1.18.1.5 pkgroot: "/opt/ghc/7.8.4/lib/ghc-7.8.4" --- name: template-haskell version: 2.9.0.0 id: template-haskell-2.9.0.0-6d27c2b362b15abb1822f2f34b9ae7f9 license: BSD3 copyright: maintainer: libraries@haskell.org stability: homepage: package-url: synopsis: Support library for Template Haskell description: This package provides modules containing facilities for manipulating Haskell source code using Template Haskell. . See for more information. category: Template Haskell author: exposed: True exposed-modules: Language.Haskell.TH Language.Haskell.TH.Lib Language.Haskell.TH.Ppr Language.Haskell.TH.PprLib Language.Haskell.TH.Quote Language.Haskell.TH.Syntax hidden-modules: trusted: False import-dirs: /opt/ghc/7.8.4/lib/ghc-7.8.4/template-haskell-2.9.0.0 library-dirs: /opt/ghc/7.8.4/lib/ghc-7.8.4/template-haskell-2.9.0.0 hs-libraries: HStemplate-haskell-2.9.0.0 extra-libraries: extra-ghci-libraries: include-dirs: includes: depends: base-4.7.0.2-bfd89587617e381ae01b8dd7b6c7f1c1 containers-0.5.5.1-d4bd887fb97aa3a46cbadc13709b7653 pretty-1.1.1.1-0984f47ffe93ef3983c80b96280f1c3a hugs-options: cc-options: ld-options: framework-dirs: frameworks: haddock-interfaces: /opt/ghc/7.8.4/share/doc/ghc/html/libraries/template-haskell-2.9.0.0/template-haskell.haddock haddock-html: /opt/ghc/7.8.4/share/doc/ghc/html/libraries/template-haskell-2.9.0.0 pkgroot: "/opt/ghc/7.8.4/lib/ghc-7.8.4" --- name: pretty version: 1.1.1.1 id: pretty-1.1.1.1-0984f47ffe93ef3983c80b96280f1c3a license: BSD3 copyright: maintainer: David Terei stability: Stable homepage: http://github.com/haskell/pretty package-url: synopsis: Pretty-printing library description: This package contains a pretty-printing library, a set of API's that provides a way to easily print out text in a consistent format of your choosing. This is useful for compilers and related tools. . This library was originally designed by John Hughes's and has since been heavily modified by Simon Peyton Jones. category: Text author: exposed: True exposed-modules: Text.PrettyPrint Text.PrettyPrint.HughesPJ hidden-modules: trusted: False import-dirs: /opt/ghc/7.8.4/lib/ghc-7.8.4/pretty-1.1.1.1 library-dirs: /opt/ghc/7.8.4/lib/ghc-7.8.4/pretty-1.1.1.1 hs-libraries: HSpretty-1.1.1.1 extra-libraries: extra-ghci-libraries: include-dirs: includes: depends: base-4.7.0.2-bfd89587617e381ae01b8dd7b6c7f1c1 hugs-options: cc-options: ld-options: framework-dirs: frameworks: haddock-interfaces: /opt/ghc/7.8.4/share/doc/ghc/html/libraries/pretty-1.1.1.1/pretty.haddock haddock-html: /opt/ghc/7.8.4/share/doc/ghc/html/libraries/pretty-1.1.1.1 pkgroot: "/opt/ghc/7.8.4/lib/ghc-7.8.4" --- name: hpc version: 0.6.0.1 id: hpc-0.6.0.1-cca17f12dab542e09c423a74a4590c5d license: BSD3 copyright: maintainer: libraries@haskell.org stability: homepage: package-url: synopsis: Code Coverage Library for Haskell description: This package provides the code coverage library for Haskell. . See for more information. category: Control author: Andy Gill exposed: True exposed-modules: Trace.Hpc.Util Trace.Hpc.Mix Trace.Hpc.Tix Trace.Hpc.Reflect hidden-modules: trusted: False import-dirs: /opt/ghc/7.8.4/lib/ghc-7.8.4/hpc-0.6.0.1 library-dirs: /opt/ghc/7.8.4/lib/ghc-7.8.4/hpc-0.6.0.1 hs-libraries: HShpc-0.6.0.1 extra-libraries: extra-ghci-libraries: include-dirs: includes: depends: base-4.7.0.2-bfd89587617e381ae01b8dd7b6c7f1c1 containers-0.5.5.1-d4bd887fb97aa3a46cbadc13709b7653 directory-1.2.1.0-07cd1f59e3c6cac5e3e180019c59a115 time-1.4.2-9b3076800c33f8382c38628f35717951 hugs-options: cc-options: ld-options: framework-dirs: frameworks: haddock-interfaces: /opt/ghc/7.8.4/share/doc/ghc/html/libraries/hpc-0.6.0.1/hpc.haddock haddock-html: /opt/ghc/7.8.4/share/doc/ghc/html/libraries/hpc-0.6.0.1 pkgroot: "/opt/ghc/7.8.4/lib/ghc-7.8.4" --- name: process version: 1.2.0.0 id: process-1.2.0.0-06c3215a79834ce4886ae686a0f81122 license: BSD3 copyright: maintainer: libraries@haskell.org stability: homepage: package-url: synopsis: Process libraries description: This package contains libraries for dealing with system processes. category: System author: exposed: True exposed-modules: System.Cmd System.Process System.Process.Internals hidden-modules: trusted: False import-dirs: /opt/ghc/7.8.4/lib/ghc-7.8.4/process-1.2.0.0 library-dirs: /opt/ghc/7.8.4/lib/ghc-7.8.4/process-1.2.0.0 hs-libraries: HSprocess-1.2.0.0 extra-libraries: extra-ghci-libraries: include-dirs: /opt/ghc/7.8.4/lib/ghc-7.8.4/process-1.2.0.0/include includes: runProcess.h depends: base-4.7.0.2-bfd89587617e381ae01b8dd7b6c7f1c1 deepseq-1.3.0.2-63a1ab91b7017a28bb5d04cb1b5d2d02 directory-1.2.1.0-07cd1f59e3c6cac5e3e180019c59a115 filepath-1.3.0.2-25a474a9272ae6260626ce0d70ad1cab unix-2.7.0.1-f8658ba9ec1c4fba8a371a8e0f42ec6c hugs-options: cc-options: ld-options: framework-dirs: frameworks: haddock-interfaces: /opt/ghc/7.8.4/share/doc/ghc/html/libraries/process-1.2.0.0/process.haddock haddock-html: /opt/ghc/7.8.4/share/doc/ghc/html/libraries/process-1.2.0.0 pkgroot: "/opt/ghc/7.8.4/lib/ghc-7.8.4" --- name: directory version: 1.2.1.0 id: directory-1.2.1.0-07cd1f59e3c6cac5e3e180019c59a115 license: BSD3 copyright: maintainer: libraries@haskell.org stability: homepage: package-url: synopsis: library for directory handling description: This package provides a library for handling directories. category: System author: exposed: True exposed-modules: System.Directory hidden-modules: trusted: False import-dirs: /opt/ghc/7.8.4/lib/ghc-7.8.4/directory-1.2.1.0 library-dirs: /opt/ghc/7.8.4/lib/ghc-7.8.4/directory-1.2.1.0 hs-libraries: HSdirectory-1.2.1.0 extra-libraries: extra-ghci-libraries: include-dirs: /opt/ghc/7.8.4/lib/ghc-7.8.4/directory-1.2.1.0/include includes: HsDirectory.h depends: base-4.7.0.2-bfd89587617e381ae01b8dd7b6c7f1c1 filepath-1.3.0.2-25a474a9272ae6260626ce0d70ad1cab time-1.4.2-9b3076800c33f8382c38628f35717951 unix-2.7.0.1-f8658ba9ec1c4fba8a371a8e0f42ec6c hugs-options: cc-options: ld-options: framework-dirs: frameworks: haddock-interfaces: /opt/ghc/7.8.4/share/doc/ghc/html/libraries/directory-1.2.1.0/directory.haddock haddock-html: /opt/ghc/7.8.4/share/doc/ghc/html/libraries/directory-1.2.1.0 pkgroot: "/opt/ghc/7.8.4/lib/ghc-7.8.4" --- name: unix version: 2.7.0.1 id: unix-2.7.0.1-f8658ba9ec1c4fba8a371a8e0f42ec6c license: BSD3 copyright: maintainer: libraries@haskell.org stability: homepage: package-url: synopsis: POSIX functionality description: This package gives you access to the set of operating system services standardised by POSIX 1003.1b (or the IEEE Portable Operating System Interface for Computing Environments - IEEE Std. 1003.1). . The package is not supported under Windows (except under Cygwin). category: System author: exposed: True exposed-modules: System.Posix System.Posix.ByteString System.Posix.Error System.Posix.Resource System.Posix.Time System.Posix.Unistd System.Posix.User System.Posix.Signals System.Posix.Signals.Exts System.Posix.Semaphore System.Posix.SharedMem System.Posix.ByteString.FilePath System.Posix.Directory System.Posix.Directory.ByteString System.Posix.DynamicLinker.Module System.Posix.DynamicLinker.Module.ByteString System.Posix.DynamicLinker.Prim System.Posix.DynamicLinker.ByteString System.Posix.DynamicLinker System.Posix.Files System.Posix.Files.ByteString System.Posix.IO System.Posix.IO.ByteString System.Posix.Env System.Posix.Env.ByteString System.Posix.Process System.Posix.Process.Internals System.Posix.Process.ByteString System.Posix.Temp System.Posix.Temp.ByteString System.Posix.Terminal System.Posix.Terminal.ByteString hidden-modules: System.Posix.Directory.Common System.Posix.DynamicLinker.Common System.Posix.Files.Common System.Posix.IO.Common System.Posix.Process.Common System.Posix.Terminal.Common trusted: False import-dirs: /opt/ghc/7.8.4/lib/ghc-7.8.4/unix-2.7.0.1 library-dirs: /opt/ghc/7.8.4/lib/ghc-7.8.4/unix-2.7.0.1 hs-libraries: HSunix-2.7.0.1 extra-libraries: rt util dl pthread extra-ghci-libraries: include-dirs: /opt/ghc/7.8.4/lib/ghc-7.8.4/unix-2.7.0.1/include includes: HsUnix.h execvpe.h depends: base-4.7.0.2-bfd89587617e381ae01b8dd7b6c7f1c1 bytestring-0.10.4.0-d6f1d17d717e8652498cab8269a0acd5 time-1.4.2-9b3076800c33f8382c38628f35717951 hugs-options: cc-options: ld-options: framework-dirs: frameworks: haddock-interfaces: /opt/ghc/7.8.4/share/doc/ghc/html/libraries/unix-2.7.0.1/unix.haddock haddock-html: /opt/ghc/7.8.4/share/doc/ghc/html/libraries/unix-2.7.0.1 pkgroot: "/opt/ghc/7.8.4/lib/ghc-7.8.4" --- name: time version: 1.4.2 id: time-1.4.2-9b3076800c33f8382c38628f35717951 license: BSD3 copyright: maintainer: stability: stable homepage: http://semantic.org/TimeLib/ package-url: synopsis: A time library description: A time library category: System author: Ashley Yakeley exposed: True exposed-modules: Data.Time.Calendar Data.Time.Calendar.MonthDay Data.Time.Calendar.OrdinalDate Data.Time.Calendar.WeekDate Data.Time.Calendar.Julian Data.Time.Calendar.Easter Data.Time.Clock Data.Time.Clock.POSIX Data.Time.Clock.TAI Data.Time.LocalTime Data.Time.Format Data.Time hidden-modules: Data.Time.Calendar.Private Data.Time.Calendar.Days Data.Time.Calendar.Gregorian Data.Time.Calendar.JulianYearDay Data.Time.Clock.Scale Data.Time.Clock.UTC Data.Time.Clock.CTimeval Data.Time.Clock.UTCDiff Data.Time.LocalTime.TimeZone Data.Time.LocalTime.TimeOfDay Data.Time.LocalTime.LocalTime Data.Time.Format.Parse trusted: False import-dirs: /opt/ghc/7.8.4/lib/ghc-7.8.4/time-1.4.2 library-dirs: /opt/ghc/7.8.4/lib/ghc-7.8.4/time-1.4.2 hs-libraries: HStime-1.4.2 extra-libraries: extra-ghci-libraries: include-dirs: /opt/ghc/7.8.4/lib/ghc-7.8.4/time-1.4.2/include includes: depends: base-4.7.0.2-bfd89587617e381ae01b8dd7b6c7f1c1 deepseq-1.3.0.2-63a1ab91b7017a28bb5d04cb1b5d2d02 old-locale-1.0.0.6-50b0125c49f76af85dc7aa22975cdc34 hugs-options: cc-options: ld-options: framework-dirs: frameworks: haddock-interfaces: /opt/ghc/7.8.4/share/doc/ghc/html/libraries/time-1.4.2/time.haddock haddock-html: /opt/ghc/7.8.4/share/doc/ghc/html/libraries/time-1.4.2 pkgroot: "/opt/ghc/7.8.4/lib/ghc-7.8.4" --- name: old-locale version: 1.0.0.6 id: old-locale-1.0.0.6-50b0125c49f76af85dc7aa22975cdc34 license: BSD3 copyright: maintainer: libraries@haskell.org stability: homepage: package-url: synopsis: locale library description: This package provides the ability to adapt to locale conventions such as date and time formats. category: System author: exposed: True exposed-modules: System.Locale hidden-modules: trusted: False import-dirs: /opt/ghc/7.8.4/lib/ghc-7.8.4/old-locale-1.0.0.6 library-dirs: /opt/ghc/7.8.4/lib/ghc-7.8.4/old-locale-1.0.0.6 hs-libraries: HSold-locale-1.0.0.6 extra-libraries: extra-ghci-libraries: include-dirs: includes: depends: base-4.7.0.2-bfd89587617e381ae01b8dd7b6c7f1c1 hugs-options: cc-options: ld-options: framework-dirs: frameworks: haddock-interfaces: /opt/ghc/7.8.4/share/doc/ghc/html/libraries/old-locale-1.0.0.6/old-locale.haddock haddock-html: /opt/ghc/7.8.4/share/doc/ghc/html/libraries/old-locale-1.0.0.6 pkgroot: "/opt/ghc/7.8.4/lib/ghc-7.8.4" --- name: containers version: 0.5.5.1 id: containers-0.5.5.1-d4bd887fb97aa3a46cbadc13709b7653 license: BSD3 copyright: maintainer: fox@ucw.cz stability: homepage: package-url: synopsis: Assorted concrete container types description: This package contains efficient general-purpose implementations of various basic immutable container types. The declared cost of each operation is either worst-case or amortized, but remains valid even if structures are shared. category: Data Structures author: exposed: True exposed-modules: Data.IntMap Data.IntMap.Lazy Data.IntMap.Strict Data.IntSet Data.Map Data.Map.Lazy Data.Map.Strict Data.Set Data.Graph Data.Sequence Data.Tree hidden-modules: Data.BitUtil Data.IntMap.Base Data.IntSet.Base Data.Map.Base Data.Set.Base Data.StrictPair trusted: False import-dirs: /opt/ghc/7.8.4/lib/ghc-7.8.4/containers-0.5.5.1 library-dirs: /opt/ghc/7.8.4/lib/ghc-7.8.4/containers-0.5.5.1 hs-libraries: HScontainers-0.5.5.1 extra-libraries: extra-ghci-libraries: include-dirs: includes: depends: array-0.5.0.0-470385a50d2b78598af85cfe9d988e1b base-4.7.0.2-bfd89587617e381ae01b8dd7b6c7f1c1 deepseq-1.3.0.2-63a1ab91b7017a28bb5d04cb1b5d2d02 ghc-prim-0.3.1.0-a24f9c14c632d75b683d0f93283aea37 hugs-options: cc-options: ld-options: framework-dirs: frameworks: haddock-interfaces: /opt/ghc/7.8.4/share/doc/ghc/html/libraries/containers-0.5.5.1/containers.haddock haddock-html: /opt/ghc/7.8.4/share/doc/ghc/html/libraries/containers-0.5.5.1 pkgroot: "/opt/ghc/7.8.4/lib/ghc-7.8.4" --- name: bytestring version: 0.10.4.0 id: bytestring-0.10.4.0-d6f1d17d717e8652498cab8269a0acd5 license: BSD3 copyright: Copyright (c) Don Stewart 2005-2009, (c) Duncan Coutts 2006-2013, (c) David Roundy 2003-2005, (c) Jasper Van der Jeugt 2010, (c) Simon Meier 2010-2013. maintainer: Don Stewart , Duncan Coutts stability: homepage: https://github.com/haskell/bytestring package-url: synopsis: Fast, compact, strict and lazy byte strings with a list interface description: An efficient compact, immutable byte string type (both strict and lazy) suitable for binary or 8-bit character data. . The 'ByteString' type represents sequences of bytes or 8-bit characters. It is suitable for high performance use, both in terms of large data quantities, or high speed requirements. The 'ByteString' functions follow the same style as Haskell\'s ordinary lists, so it is easy to convert code from using 'String' to 'ByteString'. . Two 'ByteString' variants are provided: . * Strict 'ByteString's keep the string as a single large array. This makes them convenient for passing data between C and Haskell. . * Lazy 'ByteString's use a lazy list of strict chunks which makes it suitable for I\/O streaming tasks. . The @Char8@ modules provide a character-based view of the same underlying 'ByteString' types. This makes it convenient to handle mixed binary and 8-bit character content (which is common in many file formats and network protocols). . The 'Builder' module provides an efficient way to build up 'ByteString's in an ad-hoc way by repeated concatenation. This is ideal for fast serialisation or pretty printing. . There is also a 'ShortByteString' type which has a lower memory overhead and can can be converted to or from a 'ByteString', but supports very few other operations. It is suitable for keeping many short strings in memory. . 'ByteString's are not designed for Unicode. For Unicode strings you should use the 'Text' type from the @text@ package. . These modules are intended to be imported qualified, to avoid name clashes with "Prelude" functions, e.g. . > import qualified Data.ByteString as BS category: Data author: Don Stewart, Duncan Coutts exposed: True exposed-modules: Data.ByteString Data.ByteString.Char8 Data.ByteString.Unsafe Data.ByteString.Internal Data.ByteString.Lazy Data.ByteString.Lazy.Char8 Data.ByteString.Lazy.Internal Data.ByteString.Short Data.ByteString.Short.Internal Data.ByteString.Builder Data.ByteString.Builder.Extra Data.ByteString.Builder.Prim Data.ByteString.Builder.Internal Data.ByteString.Builder.Prim.Internal Data.ByteString.Lazy.Builder Data.ByteString.Lazy.Builder.Extras Data.ByteString.Lazy.Builder.ASCII hidden-modules: Data.ByteString.Builder.ASCII Data.ByteString.Builder.Prim.Binary Data.ByteString.Builder.Prim.ASCII Data.ByteString.Builder.Prim.Internal.Floating Data.ByteString.Builder.Prim.Internal.UncheckedShifts Data.ByteString.Builder.Prim.Internal.Base16 trusted: False import-dirs: /opt/ghc/7.8.4/lib/ghc-7.8.4/bytestring-0.10.4.0 library-dirs: /opt/ghc/7.8.4/lib/ghc-7.8.4/bytestring-0.10.4.0 hs-libraries: HSbytestring-0.10.4.0 extra-libraries: extra-ghci-libraries: include-dirs: /opt/ghc/7.8.4/lib/ghc-7.8.4/bytestring-0.10.4.0/include includes: fpstring.h depends: base-4.7.0.2-bfd89587617e381ae01b8dd7b6c7f1c1 deepseq-1.3.0.2-63a1ab91b7017a28bb5d04cb1b5d2d02 ghc-prim-0.3.1.0-a24f9c14c632d75b683d0f93283aea37 integer-gmp-0.5.1.0-26579559b3647acf4f01d5edd9491a46 hugs-options: cc-options: ld-options: framework-dirs: frameworks: haddock-interfaces: /opt/ghc/7.8.4/share/doc/ghc/html/libraries/bytestring-0.10.4.0/bytestring.haddock haddock-html: /opt/ghc/7.8.4/share/doc/ghc/html/libraries/bytestring-0.10.4.0 pkgroot: "/opt/ghc/7.8.4/lib/ghc-7.8.4" --- name: deepseq version: 1.3.0.2 id: deepseq-1.3.0.2-63a1ab91b7017a28bb5d04cb1b5d2d02 license: BSD3 copyright: maintainer: libraries@haskell.org stability: homepage: package-url: synopsis: Deep evaluation of data structures description: This package provides methods for fully evaluating data structures (\"deep evaluation\"). Deep evaluation is often used for adding strictness to a program, e.g. in order to force pending exceptions, remove space leaks, or force lazy I/O to happen. It is also useful in parallel programs, to ensure pending work does not migrate to the wrong thread. . The primary use of this package is via the 'deepseq' function, a \"deep\" version of 'seq'. It is implemented on top of an 'NFData' typeclass (\"Normal Form Data\", data structures with no unevaluated components) which defines strategies for fully evaluating different data types. . If you want to automatically derive 'NFData' instances via the "GHC.Generics" facility, there is a companion package which builds on top of this package. category: Control author: exposed: True exposed-modules: Control.DeepSeq hidden-modules: trusted: False import-dirs: /opt/ghc/7.8.4/lib/ghc-7.8.4/deepseq-1.3.0.2 library-dirs: /opt/ghc/7.8.4/lib/ghc-7.8.4/deepseq-1.3.0.2 hs-libraries: HSdeepseq-1.3.0.2 extra-libraries: extra-ghci-libraries: include-dirs: includes: depends: array-0.5.0.0-470385a50d2b78598af85cfe9d988e1b base-4.7.0.2-bfd89587617e381ae01b8dd7b6c7f1c1 hugs-options: cc-options: ld-options: framework-dirs: frameworks: haddock-interfaces: /opt/ghc/7.8.4/share/doc/ghc/html/libraries/deepseq-1.3.0.2/deepseq.haddock haddock-html: /opt/ghc/7.8.4/share/doc/ghc/html/libraries/deepseq-1.3.0.2 pkgroot: "/opt/ghc/7.8.4/lib/ghc-7.8.4" --- name: array version: 0.5.0.0 id: array-0.5.0.0-470385a50d2b78598af85cfe9d988e1b license: BSD3 copyright: maintainer: libraries@haskell.org stability: homepage: package-url: synopsis: Mutable and immutable arrays description: In addition to providing the "Data.Array" module , this package also defines the classes 'IArray' of immutable arrays and 'MArray' of arrays mutable within appropriate monads, as well as some instances of these classes. category: Data Structures author: exposed: True exposed-modules: Data.Array Data.Array.Base Data.Array.IArray Data.Array.IO Data.Array.IO.Safe Data.Array.IO.Internals Data.Array.MArray Data.Array.MArray.Safe Data.Array.ST Data.Array.ST.Safe Data.Array.Storable Data.Array.Storable.Safe Data.Array.Storable.Internals Data.Array.Unboxed Data.Array.Unsafe hidden-modules: trusted: False import-dirs: /opt/ghc/7.8.4/lib/ghc-7.8.4/array-0.5.0.0 library-dirs: /opt/ghc/7.8.4/lib/ghc-7.8.4/array-0.5.0.0 hs-libraries: HSarray-0.5.0.0 extra-libraries: extra-ghci-libraries: include-dirs: includes: depends: base-4.7.0.2-bfd89587617e381ae01b8dd7b6c7f1c1 hugs-options: cc-options: ld-options: framework-dirs: frameworks: haddock-interfaces: /opt/ghc/7.8.4/share/doc/ghc/html/libraries/array-0.5.0.0/array.haddock haddock-html: /opt/ghc/7.8.4/share/doc/ghc/html/libraries/array-0.5.0.0 pkgroot: "/opt/ghc/7.8.4/lib/ghc-7.8.4" --- name: filepath version: 1.3.0.2 id: filepath-1.3.0.2-25a474a9272ae6260626ce0d70ad1cab license: BSD3 copyright: maintainer: libraries@haskell.org stability: homepage: http://www-users.cs.york.ac.uk/~ndm/filepath/ package-url: synopsis: Library for manipulating FilePaths in a cross platform way. description: A library for 'FilePath' manipulations, using Posix or Windows filepaths depending on the platform. . Both "System.FilePath.Posix" and "System.FilePath.Windows" provide the same interface. See either for examples and a list of the available functions. category: System author: Neil Mitchell exposed: True exposed-modules: System.FilePath System.FilePath.Posix System.FilePath.Windows hidden-modules: trusted: False import-dirs: /opt/ghc/7.8.4/lib/ghc-7.8.4/filepath-1.3.0.2 library-dirs: /opt/ghc/7.8.4/lib/ghc-7.8.4/filepath-1.3.0.2 hs-libraries: HSfilepath-1.3.0.2 extra-libraries: extra-ghci-libraries: include-dirs: includes: depends: base-4.7.0.2-bfd89587617e381ae01b8dd7b6c7f1c1 hugs-options: cc-options: ld-options: framework-dirs: frameworks: haddock-interfaces: /opt/ghc/7.8.4/share/doc/ghc/html/libraries/filepath-1.3.0.2/filepath.haddock haddock-html: /opt/ghc/7.8.4/share/doc/ghc/html/libraries/filepath-1.3.0.2 pkgroot: "/opt/ghc/7.8.4/lib/ghc-7.8.4" --- name: base version: 4.7.0.2 id: base-4.7.0.2-bfd89587617e381ae01b8dd7b6c7f1c1 license: BSD3 copyright: maintainer: libraries@haskell.org stability: homepage: package-url: synopsis: Basic libraries description: This package contains the "Prelude" and its support libraries, and a large collection of useful libraries ranging from data structures to parsing combinators and debugging utilities. category: Prelude author: exposed: True exposed-modules: Control.Applicative Control.Arrow Control.Category Control.Concurrent Control.Concurrent.Chan Control.Concurrent.MVar Control.Concurrent.QSem Control.Concurrent.QSemN Control.Exception Control.Exception.Base Control.Monad Control.Monad.Fix Control.Monad.Instances Control.Monad.ST Control.Monad.ST.Lazy Control.Monad.ST.Lazy.Safe Control.Monad.ST.Lazy.Unsafe Control.Monad.ST.Safe Control.Monad.ST.Strict Control.Monad.ST.Unsafe Control.Monad.Zip Data.Bits Data.Bool Data.Char Data.Coerce Data.Complex Data.Data Data.Dynamic Data.Either Data.Eq Data.Fixed Data.Foldable Data.Function Data.Functor Data.IORef Data.Int Data.Ix Data.List Data.Maybe Data.Monoid Data.OldTypeable Data.OldTypeable.Internal Data.Ord Data.Proxy Data.Ratio Data.STRef Data.STRef.Lazy Data.STRef.Strict Data.String Data.Traversable Data.Tuple Data.Type.Bool Data.Type.Coercion Data.Type.Equality Data.Typeable Data.Typeable.Internal Data.Unique Data.Version Data.Word Debug.Trace Foreign Foreign.C Foreign.C.Error Foreign.C.String Foreign.C.Types Foreign.Concurrent Foreign.ForeignPtr Foreign.ForeignPtr.Safe Foreign.ForeignPtr.Unsafe Foreign.Marshal Foreign.Marshal.Alloc Foreign.Marshal.Array Foreign.Marshal.Error Foreign.Marshal.Pool Foreign.Marshal.Safe Foreign.Marshal.Unsafe Foreign.Marshal.Utils Foreign.Ptr Foreign.Safe Foreign.StablePtr Foreign.Storable GHC.Arr GHC.Base GHC.Char GHC.Conc GHC.Conc.IO GHC.Conc.Signal GHC.Conc.Sync GHC.ConsoleHandler GHC.Constants GHC.Desugar GHC.Enum GHC.Environment GHC.Err GHC.Exception GHC.Exts GHC.Fingerprint GHC.Fingerprint.Type GHC.Float GHC.Float.ConversionUtils GHC.Float.RealFracMethods GHC.Foreign GHC.ForeignPtr GHC.GHCi GHC.Generics GHC.IO GHC.IO.Buffer GHC.IO.BufferedIO GHC.IO.Device GHC.IO.Encoding GHC.IO.Encoding.CodePage GHC.IO.Encoding.Failure GHC.IO.Encoding.Iconv GHC.IO.Encoding.Latin1 GHC.IO.Encoding.Types GHC.IO.Encoding.UTF16 GHC.IO.Encoding.UTF32 GHC.IO.Encoding.UTF8 GHC.IO.Exception GHC.IO.FD GHC.IO.Handle GHC.IO.Handle.FD GHC.IO.Handle.Internals GHC.IO.Handle.Text GHC.IO.Handle.Types GHC.IO.IOMode GHC.IOArray GHC.IORef GHC.IP GHC.Int GHC.List GHC.MVar GHC.Num GHC.PArr GHC.Pack GHC.Profiling GHC.Ptr GHC.Read GHC.Real GHC.ST GHC.STRef GHC.Show GHC.Stable GHC.Stack GHC.Stats GHC.Storable GHC.TopHandler GHC.TypeLits GHC.Unicode GHC.Weak GHC.Word Numeric Prelude System.CPUTime System.Console.GetOpt System.Environment System.Exit System.IO System.IO.Error System.IO.Unsafe System.Info System.Mem System.Mem.StableName System.Mem.Weak System.Posix.Internals System.Posix.Types System.Timeout Text.ParserCombinators.ReadP Text.ParserCombinators.ReadPrec Text.Printf Text.Read Text.Read.Lex Text.Show Text.Show.Functions Unsafe.Coerce GHC.Event hidden-modules: Control.Monad.ST.Imp Control.Monad.ST.Lazy.Imp Foreign.ForeignPtr.Imp System.Environment.ExecutablePath GHC.Event.Arr GHC.Event.Array GHC.Event.Clock GHC.Event.Control GHC.Event.EPoll GHC.Event.IntTable GHC.Event.Internal GHC.Event.KQueue GHC.Event.Manager GHC.Event.PSQ GHC.Event.Poll GHC.Event.Thread GHC.Event.TimerManager GHC.Event.Unique trusted: False import-dirs: /opt/ghc/7.8.4/lib/ghc-7.8.4/base-4.7.0.2 library-dirs: /opt/ghc/7.8.4/lib/ghc-7.8.4/base-4.7.0.2 hs-libraries: HSbase-4.7.0.2 extra-libraries: extra-ghci-libraries: include-dirs: /opt/ghc/7.8.4/lib/ghc-7.8.4/base-4.7.0.2/include includes: HsBase.h depends: ghc-prim-0.3.1.0-a24f9c14c632d75b683d0f93283aea37 integer-gmp-0.5.1.0-26579559b3647acf4f01d5edd9491a46 builtin_rts hugs-options: cc-options: ld-options: framework-dirs: frameworks: haddock-interfaces: /opt/ghc/7.8.4/share/doc/ghc/html/libraries/base-4.7.0.2/base.haddock haddock-html: /opt/ghc/7.8.4/share/doc/ghc/html/libraries/base-4.7.0.2 pkgroot: "/opt/ghc/7.8.4/lib/ghc-7.8.4" --- name: integer-gmp version: 0.5.1.0 id: integer-gmp-0.5.1.0-26579559b3647acf4f01d5edd9491a46 license: BSD3 copyright: maintainer: libraries@haskell.org stability: homepage: package-url: synopsis: Integer library based on GMP description: This package provides the low-level implementation of the standard 'Integer' type based on the . . This package provides access to the internal representation of 'Integer' as well as primitive operations with no proper error handling, and should only be used directly with the utmost care. . For more details about the design of @integer-gmp@, see . category: Numerical author: exposed: True exposed-modules: GHC.Integer GHC.Integer.GMP.Internals GHC.Integer.GMP.Prim GHC.Integer.Logarithms GHC.Integer.Logarithms.Internals hidden-modules: GHC.Integer.Type trusted: False import-dirs: /opt/ghc/7.8.4/lib/ghc-7.8.4/integer-gmp-0.5.1.0 library-dirs: /opt/ghc/7.8.4/lib/ghc-7.8.4/integer-gmp-0.5.1.0 hs-libraries: HSinteger-gmp-0.5.1.0 extra-libraries: gmp extra-ghci-libraries: include-dirs: /opt/ghc/7.8.4/lib/ghc-7.8.4/integer-gmp-0.5.1.0/include includes: depends: ghc-prim-0.3.1.0-a24f9c14c632d75b683d0f93283aea37 hugs-options: cc-options: ld-options: framework-dirs: frameworks: haddock-interfaces: /opt/ghc/7.8.4/share/doc/ghc/html/libraries/integer-gmp-0.5.1.0/integer-gmp.haddock haddock-html: /opt/ghc/7.8.4/share/doc/ghc/html/libraries/integer-gmp-0.5.1.0 pkgroot: "/opt/ghc/7.8.4/lib/ghc-7.8.4" --- name: ghc-prim version: 0.3.1.0 id: ghc-prim-0.3.1.0-a24f9c14c632d75b683d0f93283aea37 license: BSD3 copyright: maintainer: libraries@haskell.org stability: homepage: package-url: synopsis: GHC primitives description: GHC primitives. category: GHC author: exposed: True exposed-modules: GHC.CString GHC.Classes GHC.Debug GHC.IntWord64 GHC.Magic GHC.PrimopWrappers GHC.Tuple GHC.Types GHC.Prim hidden-modules: trusted: False import-dirs: /opt/ghc/7.8.4/lib/ghc-7.8.4/ghc-prim-0.3.1.0 library-dirs: /opt/ghc/7.8.4/lib/ghc-7.8.4/ghc-prim-0.3.1.0 hs-libraries: HSghc-prim-0.3.1.0 extra-libraries: extra-ghci-libraries: include-dirs: includes: depends: builtin_rts hugs-options: cc-options: ld-options: framework-dirs: frameworks: haddock-interfaces: /opt/ghc/7.8.4/share/doc/ghc/html/libraries/ghc-prim-0.3.1.0/ghc-prim.haddock haddock-html: /opt/ghc/7.8.4/share/doc/ghc/html/libraries/ghc-prim-0.3.1.0 pkgroot: "/opt/ghc/7.8.4/lib/ghc-7.8.4" --- name: rts version: 1.0 id: builtin_rts license: BSD3 copyright: maintainer: glasgow-haskell-users@haskell.org stability: homepage: package-url: synopsis: description: category: author: exposed: True exposed-modules: hidden-modules: trusted: False import-dirs: library-dirs: /opt/ghc/7.8.4/lib/ghc-7.8.4/rts-1.0 hs-libraries: HSrts Cffi extra-libraries: m rt dl extra-ghci-libraries: include-dirs: /opt/ghc/7.8.4/lib/ghc-7.8.4/include includes: Stg.h depends: hugs-options: cc-options: ld-options: "-Wl,-u,ghczmprim_GHCziTypes_Izh_static_info" "-Wl,-u,ghczmprim_GHCziTypes_Czh_static_info" "-Wl,-u,ghczmprim_GHCziTypes_Fzh_static_info" "-Wl,-u,ghczmprim_GHCziTypes_Dzh_static_info" "-Wl,-u,base_GHCziPtr_Ptr_static_info" "-Wl,-u,ghczmprim_GHCziTypes_Wzh_static_info" "-Wl,-u,base_GHCziInt_I8zh_static_info" "-Wl,-u,base_GHCziInt_I16zh_static_info" "-Wl,-u,base_GHCziInt_I32zh_static_info" "-Wl,-u,base_GHCziInt_I64zh_static_info" "-Wl,-u,base_GHCziWord_W8zh_static_info" "-Wl,-u,base_GHCziWord_W16zh_static_info" "-Wl,-u,base_GHCziWord_W32zh_static_info" "-Wl,-u,base_GHCziWord_W64zh_static_info" "-Wl,-u,base_GHCziStable_StablePtr_static_info" "-Wl,-u,ghczmprim_GHCziTypes_Izh_con_info" "-Wl,-u,ghczmprim_GHCziTypes_Czh_con_info" "-Wl,-u,ghczmprim_GHCziTypes_Fzh_con_info" "-Wl,-u,ghczmprim_GHCziTypes_Dzh_con_info" "-Wl,-u,base_GHCziPtr_Ptr_con_info" "-Wl,-u,base_GHCziPtr_FunPtr_con_info" "-Wl,-u,base_GHCziStable_StablePtr_con_info" "-Wl,-u,ghczmprim_GHCziTypes_False_closure" "-Wl,-u,ghczmprim_GHCziTypes_True_closure" "-Wl,-u,base_GHCziPack_unpackCString_closure" "-Wl,-u,base_GHCziIOziException_stackOverflow_closure" "-Wl,-u,base_GHCziIOziException_heapOverflow_closure" "-Wl,-u,base_ControlziExceptionziBase_nonTermination_closure" "-Wl,-u,base_GHCziIOziException_blockedIndefinitelyOnMVar_closure" "-Wl,-u,base_GHCziIOziException_blockedIndefinitelyOnSTM_closure" "-Wl,-u,base_ControlziExceptionziBase_nestedAtomically_closure" "-Wl,-u,base_GHCziWeak_runFinalizzerBatch_closure" "-Wl,-u,base_GHCziTopHandler_flushStdHandles_closure" "-Wl,-u,base_GHCziTopHandler_runIO_closure" "-Wl,-u,base_GHCziTopHandler_runNonIO_closure" "-Wl,-u,base_GHCziConcziIO_ensureIOManagerIsRunning_closure" "-Wl,-u,base_GHCziConcziIO_ioManagerCapabilitiesChanged_closure" "-Wl,-u,base_GHCziConcziSync_runSparks_closure" "-Wl,-u,base_GHCziConcziSignal_runHandlersPtr_closure" framework-dirs: frameworks: haddock-interfaces: haddock-html: pkgroot: "/opt/ghc/7.8.4/lib/ghc-7.8.4" stack-1.9.3.1/test/package-dump/ghc-head.txt0000644000000000000000000014637313015755774016730 0ustar0000000000000000name: ghc-boot version: 0.0.0.0 id: ghc-boot-0.0.0.0 key: ghc-boot-0.0.0.0 license: BSD3 maintainer: ghc-devs@haskell.org synopsis: Shared functionality between GHC and its boot libraries description: This library is shared between GHC, ghc-pkg, and other boot libraries. . A note about "GHC.PackageDb": it only deals with the subset of the package database that the compiler cares about: modules paths etc and not package metadata like description, authors etc. It is thus not a library interface to ghc-pkg and is *not* suitable for modifying GHC package databases. . The package database format and this library are constructed in such a way that while ghc-pkg depends on Cabal, the GHC library and program do not have to depend on Cabal. exposed: True exposed-modules: GHC.Lexeme GHC.PackageDb abi: 7a24014b606b3e9dd8b7b8aa4cf35acc trusted: False import-dirs: /opt/ghc/head/lib/ghc-7.11.20151213/ghc-boot-0.0.0.0 library-dirs: /opt/ghc/head/lib/ghc-7.11.20151213/ghc-boot-0.0.0.0 data-dir: /opt/ghc/head/share/x86_64-linux-ghc-7.11.20151213/ghc-boot-0.0.0.0 hs-libraries: HSghc-boot-0.0.0.0 depends: base-4.9.0.0 binary-0.7.5.0 bytestring-0.10.7.0 directory-1.2.5.0 filepath-1.4.1.0 haddock-interfaces: /opt/ghc/head/share/doc/ghc/html/libraries/ghc-boot-0.0.0.0/ghc-boot.haddock haddock-html: /opt/ghc/head/share/doc/ghc/html/libraries/ghc-boot-0.0.0.0 --- name: ghc version: 7.11.20151213 id: ghc-7.11.20151213 key: ghc-7.11.20151213 license: BSD3 maintainer: glasgow-haskell-users@haskell.org homepage: http://www.haskell.org/ghc/ synopsis: The GHC API description: GHC's functionality can be useful for more things than just compiling Haskell programs. Important use cases are programs that analyse (and perhaps transform) Haskell code. Others include loading Haskell code dynamically in a GHCi-like manner. For this reason, a lot of GHC's functionality is made available through this package. category: Development author: The GHC Team exposed: False exposed-modules: Avail BasicTypes ConLike DataCon PatSyn Demand Debug Exception FieldLabel GhcMonad Hooks Id IdInfo Lexeme Literal Llvm Llvm.AbsSyn Llvm.MetaData Llvm.PpLlvm Llvm.Types LlvmCodeGen LlvmCodeGen.Base LlvmCodeGen.CodeGen LlvmCodeGen.Data LlvmCodeGen.Ppr LlvmCodeGen.Regs LlvmMangler MkId Module Name NameEnv NameSet OccName RdrName SrcLoc UniqSupply Unique Var VarEnv VarSet UnVarGraph BlockId CLabel Cmm CmmBuildInfoTables CmmPipeline CmmCallConv CmmCommonBlockElim CmmImplementSwitchPlans CmmContFlowOpt CmmExpr CmmInfo CmmLex CmmLint CmmLive CmmMachOp CmmSwitch CmmNode CmmOpt CmmParse CmmProcPoint CmmSink CmmType CmmUtils CmmLayoutStack MkGraph PprBase PprC PprCmm PprCmmDecl PprCmmExpr Bitmap CodeGen.Platform CodeGen.Platform.ARM CodeGen.Platform.ARM64 CodeGen.Platform.NoRegs CodeGen.Platform.PPC CodeGen.Platform.PPC_Darwin CodeGen.Platform.SPARC CodeGen.Platform.X86 CodeGen.Platform.X86_64 CgUtils StgCmm StgCmmBind StgCmmClosure StgCmmCon StgCmmEnv StgCmmExpr StgCmmForeign StgCmmHeap StgCmmHpc StgCmmArgRep StgCmmLayout StgCmmMonad StgCmmPrim StgCmmProf StgCmmTicky StgCmmUtils StgCmmExtCode SMRep CoreArity CoreFVs CoreLint CorePrep CoreSubst CoreSyn TrieMap CoreTidy CoreUnfold CoreUtils CoreSeq CoreStats MkCore PprCore PmExpr TmOracle Check Coverage Desugar DsArrows DsBinds DsCCall DsExpr DsForeign DsGRHSs DsListComp DsMonad DsUtils Match MatchCon MatchLit HsBinds HsDecls HsDoc HsExpr HsImpExp HsLit PlaceHolder HsPat HsSyn HsTypes HsUtils BinIface BuildTyCl IfaceEnv IfaceSyn IfaceType LoadIface MkIface TcIface FlagChecker Annotations BreakArray CmdLineParser CodeOutput Config Constants DriverMkDepend DriverPhases PipelineMonad DriverPipeline DynFlags ErrUtils Finder GHC GhcMake GhcPlugins DynamicLoading HeaderInfo HscMain HscStats HscTypes InteractiveEval InteractiveEvalTypes PackageConfig Packages PlatformConstants Plugins TcPluginM PprTyThing StaticFlags StaticPtrTable SysTools Elf TidyPgm Ctype HaddockUtils Lexer OptCoercion Parser RdrHsSyn ApiAnnotation ForeignCall PrelInfo PrelNames PrelRules PrimOp TysPrim TysWiredIn CostCentre ProfInit SCCfinal RnBinds RnEnv RnExpr RnHsDoc RnNames RnPat RnSource RnSplice RnTypes CoreMonad CSE FloatIn FloatOut LiberateCase OccurAnal SAT SetLevels SimplCore SimplEnv SimplMonad SimplUtils Simplify SimplStg StgStats UnariseStg Rules SpecConstr Specialise CoreToStg StgLint StgSyn CallArity DmdAnal WorkWrap WwLib FamInst Inst TcAnnotations TcArrows TcBinds TcClassDcl TcDefaults TcDeriv TcEnv TcExpr TcForeign TcGenDeriv TcGenGenerics TcHsSyn TcHsType TcInstDcls TcMType TcValidity TcMatches TcPat TcPatSyn TcRnDriver TcRnMonad TcRnTypes TcRules TcSimplify TcErrors TcTyClsDecls TcTyDecls TcTypeable TcType TcEvidence TcUnify TcInteract TcCanonical TcFlatten TcSMonad TcTypeNats TcSplice Class Coercion DsMeta THNames FamInstEnv FunDeps InstEnv TyCon CoAxiom Kind Type TyCoRep Unify Bag Binary BooleanFormula BufWrite Digraph Encoding FastFunctions FastMutInt FastString FastStringEnv Fingerprint FiniteMap FV GraphBase GraphColor GraphOps GraphPpr IOEnv ListSetOps Maybes MonadUtils OrdList Outputable Pair Panic Pretty Serialized State Stream StringBuffer UniqDFM UniqDSet UniqFM UniqSet Util Vectorise.Builtins.Base Vectorise.Builtins.Initialise Vectorise.Builtins Vectorise.Monad.Base Vectorise.Monad.Naming Vectorise.Monad.Local Vectorise.Monad.Global Vectorise.Monad.InstEnv Vectorise.Monad Vectorise.Utils.Base Vectorise.Utils.Closure Vectorise.Utils.Hoisting Vectorise.Utils.PADict Vectorise.Utils.Poly Vectorise.Utils Vectorise.Generic.Description Vectorise.Generic.PAMethods Vectorise.Generic.PADict Vectorise.Generic.PData Vectorise.Type.Env Vectorise.Type.Type Vectorise.Type.TyConDecl Vectorise.Type.Classify Vectorise.Convert Vectorise.Vect Vectorise.Var Vectorise.Env Vectorise.Exp Vectorise Hoopl.Dataflow Hoopl AsmCodeGen TargetReg NCGMonad Instruction Format Reg RegClass PIC Platform CPrim X86.Regs X86.RegInfo X86.Instr X86.Cond X86.Ppr X86.CodeGen PPC.Regs PPC.RegInfo PPC.Instr PPC.Cond PPC.Ppr PPC.CodeGen SPARC.Base SPARC.Regs SPARC.Imm SPARC.AddrMode SPARC.Cond SPARC.Instr SPARC.Stack SPARC.ShortcutJump SPARC.Ppr SPARC.CodeGen SPARC.CodeGen.Amode SPARC.CodeGen.Base SPARC.CodeGen.CondCode SPARC.CodeGen.Gen32 SPARC.CodeGen.Gen64 SPARC.CodeGen.Sanity SPARC.CodeGen.Expand RegAlloc.Liveness RegAlloc.Graph.Main RegAlloc.Graph.Stats RegAlloc.Graph.ArchBase RegAlloc.Graph.ArchX86 RegAlloc.Graph.Coalesce RegAlloc.Graph.Spill RegAlloc.Graph.SpillClean RegAlloc.Graph.SpillCost RegAlloc.Graph.TrivColorable RegAlloc.Linear.Main RegAlloc.Linear.JoinToTargets RegAlloc.Linear.State RegAlloc.Linear.Stats RegAlloc.Linear.FreeRegs RegAlloc.Linear.StackMap RegAlloc.Linear.Base RegAlloc.Linear.X86.FreeRegs RegAlloc.Linear.X86_64.FreeRegs RegAlloc.Linear.PPC.FreeRegs RegAlloc.Linear.SPARC.FreeRegs Dwarf Dwarf.Types Dwarf.Constants Convert ByteCodeAsm ByteCodeGen ByteCodeInstr ByteCodeItbls ByteCodeLink Debugger LibFFI Linker ObjLink RtClosureInspect DebuggerUtils abi: bc2e1cb7cdee2089e52f007db59a253c trusted: False import-dirs: /opt/ghc/head/lib/ghc-7.11.20151213/ghc-7.11.20151213 library-dirs: /opt/ghc/head/lib/ghc-7.11.20151213/ghc-7.11.20151213 data-dir: /opt/ghc/head/share/x86_64-linux-ghc-7.11.20151213/ghc-7.11.20151213 hs-libraries: HSghc-7.11.20151213 include-dirs: /opt/ghc/head/lib/ghc-7.11.20151213/ghc-7.11.20151213/include depends: array-0.5.1.0 base-4.9.0.0 binary-0.7.5.0 bytestring-0.10.7.0 containers-0.5.6.3 directory-1.2.5.0 filepath-1.4.1.0 ghc-boot-0.0.0.0 hoopl-3.10.2.0 hpc-0.6.0.2 process-1.4.1.0 template-haskell-2.11.0.0 time-1.5.0.1 transformers-0.4.3.0 unix-2.7.1.1 haddock-interfaces: /opt/ghc/head/share/doc/ghc/html/libraries/ghc-7.11.20151213/ghc.haddock haddock-html: /opt/ghc/head/share/doc/ghc/html/libraries/ghc-7.11.20151213 --- name: haskeline version: 0.7.2.1 id: haskeline-0.7.2.1 key: haskeline-0.7.2.1 license: BSD3 copyright: (c) Judah Jacobson maintainer: Judah Jacobson stability: Experimental homepage: http://trac.haskell.org/haskeline synopsis: A command-line interface for user input, written in Haskell. description: Haskeline provides a user interface for line input in command-line programs. This library is similar in purpose to readline, but since it is written in Haskell it is (hopefully) more easily used in other Haskell programs. . Haskeline runs both on POSIX-compatible systems and on Windows. category: User Interfaces author: Judah Jacobson exposed: True exposed-modules: System.Console.Haskeline System.Console.Haskeline.Completion System.Console.Haskeline.MonadException System.Console.Haskeline.History System.Console.Haskeline.IO hidden-modules: System.Console.Haskeline.Backend System.Console.Haskeline.Backend.WCWidth System.Console.Haskeline.Command System.Console.Haskeline.Command.Completion System.Console.Haskeline.Command.History System.Console.Haskeline.Command.KillRing System.Console.Haskeline.Directory System.Console.Haskeline.Emacs System.Console.Haskeline.InputT System.Console.Haskeline.Key System.Console.Haskeline.LineState System.Console.Haskeline.Monads System.Console.Haskeline.Prefs System.Console.Haskeline.RunCommand System.Console.Haskeline.Term System.Console.Haskeline.Command.Undo System.Console.Haskeline.Vi System.Console.Haskeline.Recover System.Console.Haskeline.Backend.Posix System.Console.Haskeline.Backend.Posix.Encoder System.Console.Haskeline.Backend.DumbTerm System.Console.Haskeline.Backend.Terminfo abi: 1084385e878ca046b1ba1b0149406b60 trusted: False import-dirs: /opt/ghc/head/lib/ghc-7.11.20151213/haskeline-0.7.2.1 library-dirs: /opt/ghc/head/lib/ghc-7.11.20151213/haskeline-0.7.2.1 data-dir: /opt/ghc/head/share/x86_64-linux-ghc-7.11.20151213/haskeline-0.7.2.1 hs-libraries: HShaskeline-0.7.2.1 depends: base-4.9.0.0 bytestring-0.10.7.0 containers-0.5.6.3 directory-1.2.5.0 filepath-1.4.1.0 terminfo-0.4.0.1 transformers-0.4.3.0 unix-2.7.1.1 haddock-interfaces: /opt/ghc/head/share/doc/ghc/html/libraries/haskeline-0.7.2.1/haskeline.haddock haddock-html: /opt/ghc/head/share/doc/ghc/html/libraries/haskeline-0.7.2.1 --- name: terminfo version: 0.4.0.1 id: terminfo-0.4.0.1 key: terminfo-0.4.0.1 license: BSD3 copyright: (c) Judah Jacobson maintainer: Judah Jacobson stability: Stable homepage: https://github.com/judah/terminfo synopsis: Haskell bindings to the terminfo library. description: This library provides an interface to the terminfo database (via bindings to the curses library). allows POSIX systems to interact with a variety of terminals using a standard set of capabilities. category: User Interfaces author: Judah Jacobson exposed: True exposed-modules: System.Console.Terminfo System.Console.Terminfo.Base System.Console.Terminfo.Cursor System.Console.Terminfo.Color System.Console.Terminfo.Edit System.Console.Terminfo.Effects System.Console.Terminfo.Keys abi: d0bd235d4bbae7f2cbb36b97e6bcfba9 trusted: False import-dirs: /opt/ghc/head/lib/ghc-7.11.20151213/terminfo-0.4.0.1 library-dirs: /opt/ghc/head/lib/ghc-7.11.20151213/terminfo-0.4.0.1 data-dir: /opt/ghc/head/share/x86_64-linux-ghc-7.11.20151213/terminfo-0.4.0.1 hs-libraries: HSterminfo-0.4.0.1 extra-libraries: tinfo includes: ncurses.h term.h depends: base-4.9.0.0 haddock-interfaces: /opt/ghc/head/share/doc/ghc/html/libraries/terminfo-0.4.0.1/terminfo.haddock haddock-html: /opt/ghc/head/share/doc/ghc/html/libraries/terminfo-0.4.0.1 --- name: xhtml version: 3000.2.1 id: xhtml-3000.2.1 key: xhtml-3000.2.1 license: BSD3 copyright: Bjorn Bringert 2004-2006, Andy Gill and the Oregon Graduate Institute of Science and Technology, 1999-2001 maintainer: Chris Dornan stability: Stable homepage: https://github.com/haskell/xhtml synopsis: An XHTML combinator library description: This package provides combinators for producing XHTML 1.0, including the Strict, Transitional and Frameset variants. category: Web, XML, Pretty Printer author: Bjorn Bringert exposed: True exposed-modules: Text.XHtml Text.XHtml.Frameset Text.XHtml.Strict Text.XHtml.Transitional Text.XHtml.Debug Text.XHtml.Table hidden-modules: Text.XHtml.Strict.Attributes Text.XHtml.Strict.Elements Text.XHtml.Frameset.Attributes Text.XHtml.Frameset.Elements Text.XHtml.Transitional.Attributes Text.XHtml.Transitional.Elements Text.XHtml.BlockTable Text.XHtml.Extras Text.XHtml.Internals abi: 932c4b6847d698115f4ad73b10e56807 trusted: False import-dirs: /opt/ghc/head/lib/ghc-7.11.20151213/xhtml-3000.2.1 library-dirs: /opt/ghc/head/lib/ghc-7.11.20151213/xhtml-3000.2.1 data-dir: /opt/ghc/head/share/x86_64-linux-ghc-7.11.20151213/xhtml-3000.2.1 hs-libraries: HSxhtml-3000.2.1 depends: base-4.9.0.0 haddock-interfaces: /opt/ghc/head/share/doc/ghc/html/libraries/xhtml-3000.2.1/xhtml.haddock haddock-html: /opt/ghc/head/share/doc/ghc/html/libraries/xhtml-3000.2.1 --- name: transformers version: 0.4.3.0 id: transformers-0.4.3.0 key: transformers-0.4.3.0 license: BSD3 maintainer: Ross Paterson synopsis: Concrete functor and monad transformers description: A portable library of functor and monad transformers, inspired by the paper \"Functional Programming with Overloading and Higher-Order Polymorphism\", by Mark P Jones, in /Advanced School of Functional Programming/, 1995 (). . This package contains: . * the monad transformer class (in "Control.Monad.Trans.Class") and IO monad class (in "Control.Monad.IO.Class") . * concrete functor and monad transformers, each with associated operations and functions to lift operations associated with other transformers. . The package can be used on its own in portable Haskell code, in which case operations need to be manually lifted through transformer stacks (see "Control.Monad.Trans.Class" for some examples). Alternatively, it can be used with the non-portable monad classes in the @mtl@ or @monads-tf@ packages, which automatically lift operations introduced by monad transformers through other transformers. category: Control author: Andy Gill, Ross Paterson exposed: True exposed-modules: Control.Applicative.Backwards Control.Applicative.Lift Control.Monad.Signatures Control.Monad.Trans.Class Control.Monad.Trans.Cont Control.Monad.Trans.Except Control.Monad.Trans.Error Control.Monad.Trans.Identity Control.Monad.Trans.List Control.Monad.Trans.Maybe Control.Monad.Trans.Reader Control.Monad.Trans.RWS Control.Monad.Trans.RWS.Lazy Control.Monad.Trans.RWS.Strict Control.Monad.Trans.State Control.Monad.Trans.State.Lazy Control.Monad.Trans.State.Strict Control.Monad.Trans.Writer Control.Monad.Trans.Writer.Lazy Control.Monad.Trans.Writer.Strict Data.Functor.Classes Data.Functor.Compose Data.Functor.Constant Data.Functor.Product Data.Functor.Reverse Data.Functor.Sum abi: d71166f18d2591685ff3ee72b17638c0 trusted: False import-dirs: /opt/ghc/head/lib/ghc-7.11.20151213/transformers-0.4.3.0 library-dirs: /opt/ghc/head/lib/ghc-7.11.20151213/transformers-0.4.3.0 data-dir: /opt/ghc/head/share/x86_64-linux-ghc-7.11.20151213/transformers-0.4.3.0 hs-libraries: HStransformers-0.4.3.0 depends: base-4.9.0.0 haddock-interfaces: /opt/ghc/head/share/doc/ghc/html/libraries/transformers-0.4.3.0/transformers.haddock haddock-html: /opt/ghc/head/share/doc/ghc/html/libraries/transformers-0.4.3.0 --- name: hoopl version: 3.10.2.0 id: hoopl-3.10.2.0 key: hoopl-3.10.2.0 license: BSD3 maintainer: nr@cs.tufts.edu, andreas.voellmy@gmail.com, email@ningwang.org homepage: http://ghc.cs.tufts.edu/hoopl/ synopsis: A library to support dataflow analysis and optimization description: Higher-order optimization library . See /Norman Ramsey, Joao Dias, and Simon Peyton Jones./ /(2010)/ for more details. category: Compilers/Interpreters author: Norman Ramsey, Joao Dias, Simon Marlow and Simon Peyton Jones exposed: True exposed-modules: Compiler.Hoopl Compiler.Hoopl.Internals Compiler.Hoopl.Wrappers Compiler.Hoopl.Passes.Dominator Compiler.Hoopl.Passes.DList hidden-modules: Compiler.Hoopl.Checkpoint Compiler.Hoopl.Collections Compiler.Hoopl.Combinators Compiler.Hoopl.Dataflow Compiler.Hoopl.Debug Compiler.Hoopl.Block Compiler.Hoopl.Graph Compiler.Hoopl.Label Compiler.Hoopl.MkGraph Compiler.Hoopl.Fuel Compiler.Hoopl.Pointed Compiler.Hoopl.Shape Compiler.Hoopl.Show Compiler.Hoopl.Unique Compiler.Hoopl.XUtil abi: 719b00050240e530b78b62520193b342 trusted: False import-dirs: /opt/ghc/head/lib/ghc-7.11.20151213/hoopl-3.10.2.0 library-dirs: /opt/ghc/head/lib/ghc-7.11.20151213/hoopl-3.10.2.0 data-dir: /opt/ghc/head/share/x86_64-linux-ghc-7.11.20151213/hoopl-3.10.2.0 hs-libraries: HShoopl-3.10.2.0 depends: base-4.9.0.0 containers-0.5.6.3 haddock-interfaces: /opt/ghc/head/share/doc/ghc/html/libraries/hoopl-3.10.2.0/hoopl.haddock haddock-html: /opt/ghc/head/share/doc/ghc/html/libraries/hoopl-3.10.2.0 --- name: template-haskell version: 2.11.0.0 id: template-haskell-2.11.0.0 key: template-haskell-2.11.0.0 license: BSD3 maintainer: libraries@haskell.org synopsis: Support library for Template Haskell description: This package provides modules containing facilities for manipulating Haskell source code using Template Haskell. . See for more information. category: Template Haskell exposed: True exposed-modules: Language.Haskell.TH Language.Haskell.TH.Lib Language.Haskell.TH.Ppr Language.Haskell.TH.PprLib Language.Haskell.TH.Quote Language.Haskell.TH.Syntax hidden-modules: Language.Haskell.TH.Lib.Map abi: 26855f7c84ab668b019a8d35abdb5276 trusted: False import-dirs: /opt/ghc/head/lib/ghc-7.11.20151213/template-haskell-2.11.0.0 library-dirs: /opt/ghc/head/lib/ghc-7.11.20151213/template-haskell-2.11.0.0 data-dir: /opt/ghc/head/share/x86_64-linux-ghc-7.11.20151213/template-haskell-2.11.0.0 hs-libraries: HStemplate-haskell-2.11.0.0 depends: base-4.9.0.0 ghc-boot-0.0.0.0 pretty-1.1.2.0 haddock-interfaces: /opt/ghc/head/share/doc/ghc/html/libraries/template-haskell-2.11.0.0/template-haskell.haddock haddock-html: /opt/ghc/head/share/doc/ghc/html/libraries/template-haskell-2.11.0.0 --- name: Cabal version: 1.23.0.0 id: Cabal-1.23.0.0 key: Cabal-1.23.0.0 license: BSD3 copyright: 2003-2006, Isaac Jones 2005-2011, Duncan Coutts maintainer: cabal-devel@haskell.org homepage: http://www.haskell.org/cabal/ synopsis: A framework for packaging Haskell software description: The Haskell Common Architecture for Building Applications and Libraries: a framework defining a common interface for authors to more easily build their Haskell applications in a portable way. . The Haskell Cabal is part of a larger infrastructure for distributing, organizing, and cataloging Haskell libraries and tools. category: Distribution author: Isaac Jones Duncan Coutts exposed: True exposed-modules: Distribution.Compat.CreatePipe Distribution.Compat.Environment Distribution.Compat.Exception Distribution.Compat.Internal.TempFile Distribution.Compat.ReadP Distribution.Compiler Distribution.InstalledPackageInfo Distribution.License Distribution.Make Distribution.ModuleName Distribution.Package Distribution.PackageDescription Distribution.PackageDescription.Check Distribution.PackageDescription.Configuration Distribution.PackageDescription.Parse Distribution.PackageDescription.PrettyPrint Distribution.PackageDescription.Utils Distribution.ParseUtils Distribution.ReadE Distribution.Simple Distribution.Simple.Bench Distribution.Simple.Build Distribution.Simple.Build.Macros Distribution.Simple.Build.PathsModule Distribution.Simple.BuildPaths Distribution.Simple.BuildTarget Distribution.Simple.CCompiler Distribution.Simple.Command Distribution.Simple.Compiler Distribution.Simple.Configure Distribution.Simple.GHC Distribution.Simple.GHCJS Distribution.Simple.Haddock Distribution.Simple.HaskellSuite Distribution.Simple.Hpc Distribution.Simple.Install Distribution.Simple.InstallDirs Distribution.Simple.JHC Distribution.Simple.LHC Distribution.Simple.LocalBuildInfo Distribution.Simple.PackageIndex Distribution.Simple.PreProcess Distribution.Simple.PreProcess.Unlit Distribution.Simple.Program Distribution.Simple.Program.Ar Distribution.Simple.Program.Builtin Distribution.Simple.Program.Db Distribution.Simple.Program.Find Distribution.Simple.Program.GHC Distribution.Simple.Program.HcPkg Distribution.Simple.Program.Hpc Distribution.Simple.Program.Internal Distribution.Simple.Program.Ld Distribution.Simple.Program.Run Distribution.Simple.Program.Script Distribution.Simple.Program.Strip Distribution.Simple.Program.Types Distribution.Simple.Register Distribution.Simple.Setup Distribution.Simple.SrcDist Distribution.Simple.Test Distribution.Simple.Test.ExeV10 Distribution.Simple.Test.LibV09 Distribution.Simple.Test.Log Distribution.Simple.UHC Distribution.Simple.UserHooks Distribution.Simple.Utils Distribution.System Distribution.TestSuite Distribution.Text Distribution.Utils.NubList Distribution.Verbosity Distribution.Version Language.Haskell.Extension hidden-modules: Distribution.Compat.Binary Distribution.Compat.CopyFile Distribution.GetOpt Distribution.Lex Distribution.Simple.GHC.Internal Distribution.Simple.GHC.IPI641 Distribution.Simple.GHC.IPI642 Distribution.Simple.GHC.ImplInfo Paths_Cabal abi: 4b55984d7d0e5898df279f52ba75702f trusted: False import-dirs: /opt/ghc/head/lib/ghc-7.11.20151213/Cabal-1.23.0.0 library-dirs: /opt/ghc/head/lib/ghc-7.11.20151213/Cabal-1.23.0.0 data-dir: /opt/ghc/head/share/x86_64-linux-ghc-7.11.20151213/Cabal-1.23.0.0 hs-libraries: HSCabal-1.23.0.0 depends: array-0.5.1.0 base-4.9.0.0 binary-0.7.5.0 bytestring-0.10.7.0 containers-0.5.6.3 deepseq-1.4.2.0 directory-1.2.5.0 filepath-1.4.1.0 pretty-1.1.2.0 process-1.4.1.0 time-1.5.0.1 unix-2.7.1.1 haddock-interfaces: /opt/ghc/head/share/doc/ghc/html/libraries/Cabal-1.23.0.0/Cabal.haddock haddock-html: /opt/ghc/head/share/doc/ghc/html/libraries/Cabal-1.23.0.0 --- name: binary version: 0.7.5.0 id: binary-0.7.5.0 key: binary-0.7.5.0 license: BSD3 maintainer: Lennart Kolmodin, Don Stewart stability: provisional homepage: https://github.com/kolmodin/binary synopsis: Binary serialisation for Haskell values using lazy ByteStrings description: Efficient, pure binary serialisation using lazy ByteStrings. Haskell values may be encoded to and from binary formats, written to disk as binary, or sent over the network. The format used can be automatically generated, or you can choose to implement a custom format if needed. Serialisation speeds of over 1 G\/sec have been observed, so this library should be suitable for high performance scenarios. category: Data, Parsing author: Lennart Kolmodin exposed: True exposed-modules: Data.Binary Data.Binary.Put Data.Binary.Get Data.Binary.Get.Internal Data.Binary.Builder Data.Binary.Builder.Internal hidden-modules: Data.Binary.Builder.Base Data.Binary.Class Data.Binary.Generic abi: 023629bb1f3d2da077b9dfaec842d5d6 trusted: False import-dirs: /opt/ghc/head/lib/ghc-7.11.20151213/binary-0.7.5.0 library-dirs: /opt/ghc/head/lib/ghc-7.11.20151213/binary-0.7.5.0 data-dir: /opt/ghc/head/share/x86_64-linux-ghc-7.11.20151213/binary-0.7.5.0 hs-libraries: HSbinary-0.7.5.0 depends: array-0.5.1.0 base-4.9.0.0 bytestring-0.10.7.0 containers-0.5.6.3 haddock-interfaces: /opt/ghc/head/share/doc/ghc/html/libraries/binary-0.7.5.0/binary.haddock haddock-html: /opt/ghc/head/share/doc/ghc/html/libraries/binary-0.7.5.0 --- name: pretty version: 1.1.2.0 id: pretty-1.1.2.0 key: pretty-1.1.2.0 license: BSD3 maintainer: David Terei stability: Stable homepage: http://github.com/haskell/pretty synopsis: Pretty-printing library description: This package contains a pretty-printing library, a set of API's that provides a way to easily print out text in a consistent format of your choosing. This is useful for compilers and related tools. . This library was originally designed by John Hughes's and has since been heavily modified by Simon Peyton Jones. category: Text exposed: True exposed-modules: Text.PrettyPrint Text.PrettyPrint.HughesPJ Text.PrettyPrint.HughesPJClass abi: ff204a4f63b87ec08dfb63935ab60346 trusted: False import-dirs: /opt/ghc/head/lib/ghc-7.11.20151213/pretty-1.1.2.0 library-dirs: /opt/ghc/head/lib/ghc-7.11.20151213/pretty-1.1.2.0 data-dir: /opt/ghc/head/share/x86_64-linux-ghc-7.11.20151213/pretty-1.1.2.0 hs-libraries: HSpretty-1.1.2.0 depends: base-4.9.0.0 deepseq-1.4.2.0 ghc-prim-0.5.0.0 haddock-interfaces: /opt/ghc/head/share/doc/ghc/html/libraries/pretty-1.1.2.0/pretty.haddock haddock-html: /opt/ghc/head/share/doc/ghc/html/libraries/pretty-1.1.2.0 --- name: hpc version: 0.6.0.2 id: hpc-0.6.0.2 key: hpc-0.6.0.2 license: BSD3 maintainer: ghc-devs@haskell.org synopsis: Code Coverage Library for Haskell description: This package provides the code coverage library for Haskell. . See for more information. category: Control author: Andy Gill exposed: True exposed-modules: Trace.Hpc.Util Trace.Hpc.Mix Trace.Hpc.Tix Trace.Hpc.Reflect abi: b98013c17bf1741c790e3a830237e8bc trusted: False import-dirs: /opt/ghc/head/lib/ghc-7.11.20151213/hpc-0.6.0.2 library-dirs: /opt/ghc/head/lib/ghc-7.11.20151213/hpc-0.6.0.2 data-dir: /opt/ghc/head/share/x86_64-linux-ghc-7.11.20151213/hpc-0.6.0.2 hs-libraries: HShpc-0.6.0.2 depends: base-4.9.0.0 containers-0.5.6.3 directory-1.2.5.0 filepath-1.4.1.0 time-1.5.0.1 haddock-interfaces: /opt/ghc/head/share/doc/ghc/html/libraries/hpc-0.6.0.2/hpc.haddock haddock-html: /opt/ghc/head/share/doc/ghc/html/libraries/hpc-0.6.0.2 --- name: process version: 1.4.1.0 id: process-1.4.1.0 key: process-1.4.1.0 license: BSD3 maintainer: libraries@haskell.org synopsis: Process libraries description: This package contains libraries for dealing with system processes. category: System exposed: True exposed-modules: System.Cmd System.Process System.Process.Internals hidden-modules: System.Process.Common System.Process.Posix abi: 483b4c1d894e8c880c567a1ee593790f trusted: False import-dirs: /opt/ghc/head/lib/ghc-7.11.20151213/process-1.4.1.0 library-dirs: /opt/ghc/head/lib/ghc-7.11.20151213/process-1.4.1.0 data-dir: /opt/ghc/head/share/x86_64-linux-ghc-7.11.20151213/process-1.4.1.0 hs-libraries: HSprocess-1.4.1.0 include-dirs: /opt/ghc/head/lib/ghc-7.11.20151213/process-1.4.1.0/include includes: runProcess.h depends: base-4.9.0.0 deepseq-1.4.2.0 directory-1.2.5.0 filepath-1.4.1.0 unix-2.7.1.1 haddock-interfaces: /opt/ghc/head/share/doc/ghc/html/libraries/process-1.4.1.0/process.haddock haddock-html: /opt/ghc/head/share/doc/ghc/html/libraries/process-1.4.1.0 --- name: directory version: 1.2.5.0 id: directory-1.2.5.0 key: directory-1.2.5.0 license: BSD3 maintainer: libraries@haskell.org synopsis: Platform-agnostic library for filesystem operations description: This library provides a basic set of operations for manipulating files and directories in a portable way. category: System exposed: True exposed-modules: System.Directory hidden-modules: System.Directory.Internal System.Directory.Internal.Config System.Directory.Internal.C_utimensat System.Directory.Internal.Posix System.Directory.Internal.Windows abi: 73051d50bd0377c1f91d40ac29eafcde trusted: False import-dirs: /opt/ghc/head/lib/ghc-7.11.20151213/directory-1.2.5.0 library-dirs: /opt/ghc/head/lib/ghc-7.11.20151213/directory-1.2.5.0 data-dir: /opt/ghc/head/share/x86_64-linux-ghc-7.11.20151213/directory-1.2.5.0 hs-libraries: HSdirectory-1.2.5.0 include-dirs: /opt/ghc/head/lib/ghc-7.11.20151213/directory-1.2.5.0/include includes: HsDirectory.h depends: base-4.9.0.0 filepath-1.4.1.0 time-1.5.0.1 unix-2.7.1.1 haddock-interfaces: /opt/ghc/head/share/doc/ghc/html/libraries/directory-1.2.5.0/directory.haddock haddock-html: /opt/ghc/head/share/doc/ghc/html/libraries/directory-1.2.5.0 --- name: unix version: 2.7.1.1 id: unix-2.7.1.1 key: unix-2.7.1.1 license: BSD3 maintainer: libraries@haskell.org homepage: https://github.com/haskell/unix synopsis: POSIX functionality description: This package gives you access to the set of operating system services standardised by POSIX 1003.1b (or the IEEE Portable Operating System Interface for Computing Environments - IEEE Std. 1003.1). . The package is not supported under Windows (except under Cygwin). category: System exposed: True exposed-modules: System.Posix System.Posix.ByteString System.Posix.Error System.Posix.Resource System.Posix.Time System.Posix.Unistd System.Posix.User System.Posix.Signals System.Posix.Signals.Exts System.Posix.Semaphore System.Posix.SharedMem System.Posix.ByteString.FilePath System.Posix.Directory System.Posix.Directory.ByteString System.Posix.DynamicLinker.Module System.Posix.DynamicLinker.Module.ByteString System.Posix.DynamicLinker.Prim System.Posix.DynamicLinker.ByteString System.Posix.DynamicLinker System.Posix.Files System.Posix.Files.ByteString System.Posix.IO System.Posix.IO.ByteString System.Posix.Env System.Posix.Env.ByteString System.Posix.Fcntl System.Posix.Process System.Posix.Process.Internals System.Posix.Process.ByteString System.Posix.Temp System.Posix.Temp.ByteString System.Posix.Terminal System.Posix.Terminal.ByteString hidden-modules: System.Posix.Directory.Common System.Posix.DynamicLinker.Common System.Posix.Files.Common System.Posix.IO.Common System.Posix.Process.Common System.Posix.Terminal.Common abi: 416bbf4a68812f768d46e0603efc98e6 trusted: False import-dirs: /opt/ghc/head/lib/ghc-7.11.20151213/unix-2.7.1.1 library-dirs: /opt/ghc/head/lib/ghc-7.11.20151213/unix-2.7.1.1 data-dir: /opt/ghc/head/share/x86_64-linux-ghc-7.11.20151213/unix-2.7.1.1 hs-libraries: HSunix-2.7.1.1 extra-libraries: rt util dl pthread include-dirs: /opt/ghc/head/lib/ghc-7.11.20151213/unix-2.7.1.1/include includes: HsUnix.h execvpe.h depends: base-4.9.0.0 bytestring-0.10.7.0 time-1.5.0.1 haddock-interfaces: /opt/ghc/head/share/doc/ghc/html/libraries/unix-2.7.1.1/unix.haddock haddock-html: /opt/ghc/head/share/doc/ghc/html/libraries/unix-2.7.1.1 --- name: time version: 1.5.0.1 id: time-1.5.0.1 key: time-1.5.0.1 license: BSD3 maintainer: stability: stable homepage: https://github.com/haskell/time synopsis: A time library description: A time library category: System author: Ashley Yakeley exposed: True exposed-modules: Data.Time.Calendar Data.Time.Calendar.MonthDay Data.Time.Calendar.OrdinalDate Data.Time.Calendar.WeekDate Data.Time.Calendar.Julian Data.Time.Calendar.Easter Data.Time.Clock Data.Time.Clock.POSIX Data.Time.Clock.TAI Data.Time.LocalTime Data.Time.Format Data.Time hidden-modules: Data.Time.Calendar.Private Data.Time.Calendar.Days Data.Time.Calendar.Gregorian Data.Time.Calendar.JulianYearDay Data.Time.Clock.Scale Data.Time.Clock.UTC Data.Time.Clock.CTimeval Data.Time.Clock.UTCDiff Data.Time.LocalTime.TimeZone Data.Time.LocalTime.TimeOfDay Data.Time.LocalTime.LocalTime Data.Time.Format.Parse Data.Time.Format.Locale abi: fa14628fffb7d93741bb88caab63757e trusted: False import-dirs: /opt/ghc/head/lib/ghc-7.11.20151213/time-1.5.0.1 library-dirs: /opt/ghc/head/lib/ghc-7.11.20151213/time-1.5.0.1 data-dir: /opt/ghc/head/share/x86_64-linux-ghc-7.11.20151213/time-1.5.0.1 hs-libraries: HStime-1.5.0.1 include-dirs: /opt/ghc/head/lib/ghc-7.11.20151213/time-1.5.0.1/include depends: base-4.9.0.0 deepseq-1.4.2.0 haddock-interfaces: /opt/ghc/head/share/doc/ghc/html/libraries/time-1.5.0.1/time.haddock haddock-html: /opt/ghc/head/share/doc/ghc/html/libraries/time-1.5.0.1 --- name: containers version: 0.5.6.3 id: containers-0.5.6.3 key: containers-0.5.6.3 license: BSD3 maintainer: fox@ucw.cz synopsis: Assorted concrete container types description: This package contains efficient general-purpose implementations of various basic immutable container types. The declared cost of each operation is either worst-case or amortized, but remains valid even if structures are shared. category: Data Structures exposed: True exposed-modules: Data.IntMap Data.IntMap.Lazy Data.IntMap.Strict Data.IntSet Data.Map Data.Map.Lazy Data.Map.Strict Data.Set Data.Graph Data.Sequence Data.Tree hidden-modules: Data.IntMap.Base Data.IntSet.Base Data.Map.Base Data.Set.Base Data.Utils.BitUtil Data.Utils.StrictFold Data.Utils.StrictPair abi: 4ae96ef90aaf7e7c342611448391c5cd trusted: False import-dirs: /opt/ghc/head/lib/ghc-7.11.20151213/containers-0.5.6.3 library-dirs: /opt/ghc/head/lib/ghc-7.11.20151213/containers-0.5.6.3 data-dir: /opt/ghc/head/share/x86_64-linux-ghc-7.11.20151213/containers-0.5.6.3 hs-libraries: HScontainers-0.5.6.3 depends: array-0.5.1.0 base-4.9.0.0 deepseq-1.4.2.0 ghc-prim-0.5.0.0 haddock-interfaces: /opt/ghc/head/share/doc/ghc/html/libraries/containers-0.5.6.3/containers.haddock haddock-html: /opt/ghc/head/share/doc/ghc/html/libraries/containers-0.5.6.3 --- name: bytestring version: 0.10.7.0 id: bytestring-0.10.7.0 key: bytestring-0.10.7.0 license: BSD3 copyright: Copyright (c) Don Stewart 2005-2009, (c) Duncan Coutts 2006-2015, (c) David Roundy 2003-2005, (c) Jasper Van der Jeugt 2010, (c) Simon Meier 2010-2013. maintainer: Duncan Coutts homepage: https://github.com/haskell/bytestring synopsis: Fast, compact, strict and lazy byte strings with a list interface description: An efficient compact, immutable byte string type (both strict and lazy) suitable for binary or 8-bit character data. . The 'ByteString' type represents sequences of bytes or 8-bit characters. It is suitable for high performance use, both in terms of large data quantities, or high speed requirements. The 'ByteString' functions follow the same style as Haskell\'s ordinary lists, so it is easy to convert code from using 'String' to 'ByteString'. . Two 'ByteString' variants are provided: . * Strict 'ByteString's keep the string as a single large array. This makes them convenient for passing data between C and Haskell. . * Lazy 'ByteString's use a lazy list of strict chunks which makes it suitable for I\/O streaming tasks. . The @Char8@ modules provide a character-based view of the same underlying 'ByteString' types. This makes it convenient to handle mixed binary and 8-bit character content (which is common in many file formats and network protocols). . The 'Builder' module provides an efficient way to build up 'ByteString's in an ad-hoc way by repeated concatenation. This is ideal for fast serialisation or pretty printing. . There is also a 'ShortByteString' type which has a lower memory overhead and can can be converted to or from a 'ByteString', but supports very few other operations. It is suitable for keeping many short strings in memory. . 'ByteString's are not designed for Unicode. For Unicode strings you should use the 'Text' type from the @text@ package. . These modules are intended to be imported qualified, to avoid name clashes with "Prelude" functions, e.g. . > import qualified Data.ByteString as BS category: Data author: Don Stewart, Duncan Coutts exposed: True exposed-modules: Data.ByteString Data.ByteString.Char8 Data.ByteString.Unsafe Data.ByteString.Internal Data.ByteString.Lazy Data.ByteString.Lazy.Char8 Data.ByteString.Lazy.Internal Data.ByteString.Short Data.ByteString.Short.Internal Data.ByteString.Builder Data.ByteString.Builder.Extra Data.ByteString.Builder.Prim Data.ByteString.Builder.Internal Data.ByteString.Builder.Prim.Internal Data.ByteString.Lazy.Builder Data.ByteString.Lazy.Builder.Extras Data.ByteString.Lazy.Builder.ASCII hidden-modules: Data.ByteString.Builder.ASCII Data.ByteString.Builder.Prim.Binary Data.ByteString.Builder.Prim.ASCII Data.ByteString.Builder.Prim.Internal.Floating Data.ByteString.Builder.Prim.Internal.UncheckedShifts Data.ByteString.Builder.Prim.Internal.Base16 abi: d9206a8fe0d44e69be0c04076cabad23 trusted: False import-dirs: /opt/ghc/head/lib/ghc-7.11.20151213/bytestring-0.10.7.0 library-dirs: /opt/ghc/head/lib/ghc-7.11.20151213/bytestring-0.10.7.0 data-dir: /opt/ghc/head/share/x86_64-linux-ghc-7.11.20151213/bytestring-0.10.7.0 hs-libraries: HSbytestring-0.10.7.0 include-dirs: /opt/ghc/head/lib/ghc-7.11.20151213/bytestring-0.10.7.0/include includes: fpstring.h depends: base-4.9.0.0 deepseq-1.4.2.0 ghc-prim-0.5.0.0 integer-gmp-1.0.0.0 haddock-interfaces: /opt/ghc/head/share/doc/ghc/html/libraries/bytestring-0.10.7.0/bytestring.haddock haddock-html: /opt/ghc/head/share/doc/ghc/html/libraries/bytestring-0.10.7.0 --- name: deepseq version: 1.4.2.0 id: deepseq-1.4.2.0 key: deepseq-1.4.2.0 license: BSD3 maintainer: libraries@haskell.org synopsis: Deep evaluation of data structures description: This package provides methods for fully evaluating data structures (\"deep evaluation\"). Deep evaluation is often used for adding strictness to a program, e.g. in order to force pending exceptions, remove space leaks, or force lazy I/O to happen. It is also useful in parallel programs, to ensure pending work does not migrate to the wrong thread. . The primary use of this package is via the 'deepseq' function, a \"deep\" version of 'seq'. It is implemented on top of an 'NFData' typeclass (\"Normal Form Data\", data structures with no unevaluated components) which defines strategies for fully evaluating different data types. category: Control exposed: True exposed-modules: Control.DeepSeq abi: 63c4c214c0c19484502b3c8b7e42ec69 trusted: False import-dirs: /opt/ghc/head/lib/ghc-7.11.20151213/deepseq-1.4.2.0 library-dirs: /opt/ghc/head/lib/ghc-7.11.20151213/deepseq-1.4.2.0 data-dir: /opt/ghc/head/share/x86_64-linux-ghc-7.11.20151213/deepseq-1.4.2.0 hs-libraries: HSdeepseq-1.4.2.0 depends: array-0.5.1.0 base-4.9.0.0 haddock-interfaces: /opt/ghc/head/share/doc/ghc/html/libraries/deepseq-1.4.2.0/deepseq.haddock haddock-html: /opt/ghc/head/share/doc/ghc/html/libraries/deepseq-1.4.2.0 --- name: array version: 0.5.1.0 id: array-0.5.1.0 key: array-0.5.1.0 license: BSD3 maintainer: libraries@haskell.org synopsis: Mutable and immutable arrays description: In addition to providing the "Data.Array" module , this package also defines the classes 'IArray' of immutable arrays and 'MArray' of arrays mutable within appropriate monads, as well as some instances of these classes. category: Data Structures exposed: True exposed-modules: Data.Array Data.Array.Base Data.Array.IArray Data.Array.IO Data.Array.IO.Safe Data.Array.IO.Internals Data.Array.MArray Data.Array.MArray.Safe Data.Array.ST Data.Array.ST.Safe Data.Array.Storable Data.Array.Storable.Safe Data.Array.Storable.Internals Data.Array.Unboxed Data.Array.Unsafe abi: 2b2b879a09eb81c865ac273803e08132 trusted: False import-dirs: /opt/ghc/head/lib/ghc-7.11.20151213/array-0.5.1.0 library-dirs: /opt/ghc/head/lib/ghc-7.11.20151213/array-0.5.1.0 data-dir: /opt/ghc/head/share/x86_64-linux-ghc-7.11.20151213/array-0.5.1.0 hs-libraries: HSarray-0.5.1.0 depends: base-4.9.0.0 haddock-interfaces: /opt/ghc/head/share/doc/ghc/html/libraries/array-0.5.1.0/array.haddock haddock-html: /opt/ghc/head/share/doc/ghc/html/libraries/array-0.5.1.0 --- name: filepath version: 1.4.1.0 id: filepath-1.4.1.0 key: filepath-1.4.1.0 license: BSD3 copyright: Neil Mitchell 2005-2015 maintainer: Neil Mitchell homepage: https://github.com/haskell/filepath#readme synopsis: Library for manipulating FilePaths in a cross platform way. description: This package provides functionality for manipulating @FilePath@ values, and is shipped with both and the . It provides three modules: . * "System.FilePath.Posix" manipulates POSIX\/Linux style @FilePath@ values (with @\/@ as the path separator). . * "System.FilePath.Windows" manipulates Windows style @FilePath@ values (with either @\\@ or @\/@ as the path separator, and deals with drives). . * "System.FilePath" is an alias for the module appropriate to your platform. . All three modules provide the same API, and the same documentation (calling out differences in the different variants). category: System author: Neil Mitchell exposed: True exposed-modules: System.FilePath System.FilePath.Posix System.FilePath.Windows abi: 1e3d9055afc6aa08b97f5ad5f8014ce4 trusted: False import-dirs: /opt/ghc/head/lib/ghc-7.11.20151213/filepath-1.4.1.0 library-dirs: /opt/ghc/head/lib/ghc-7.11.20151213/filepath-1.4.1.0 data-dir: /opt/ghc/head/share/x86_64-linux-ghc-7.11.20151213/filepath-1.4.1.0 hs-libraries: HSfilepath-1.4.1.0 depends: base-4.9.0.0 haddock-interfaces: /opt/ghc/head/share/doc/ghc/html/libraries/filepath-1.4.1.0/filepath.haddock haddock-html: /opt/ghc/head/share/doc/ghc/html/libraries/filepath-1.4.1.0 --- name: base version: 4.9.0.0 id: base-4.9.0.0 key: base-4.9.0.0 license: BSD3 maintainer: libraries@haskell.org synopsis: Basic libraries description: This package contains the "Prelude" and its support libraries, and a large collection of useful libraries ranging from data structures to parsing combinators and debugging utilities. category: Prelude exposed: True exposed-modules: Control.Applicative Control.Arrow Control.Category Control.Concurrent Control.Concurrent.Chan Control.Concurrent.MVar Control.Concurrent.QSem Control.Concurrent.QSemN Control.Exception Control.Exception.Base Control.Monad Control.Monad.Fail Control.Monad.Fix Control.Monad.Instances Control.Monad.IO.Class Control.Monad.ST Control.Monad.ST.Lazy Control.Monad.ST.Lazy.Safe Control.Monad.ST.Lazy.Unsafe Control.Monad.ST.Safe Control.Monad.ST.Strict Control.Monad.ST.Unsafe Control.Monad.Zip Data.Bifunctor Data.Bits Data.Bool Data.Char Data.Coerce Data.Complex Data.Data Data.Dynamic Data.Either Data.Eq Data.Fixed Data.Foldable Data.Function Data.Functor Data.Functor.Identity Data.IORef Data.Int Data.Ix Data.Kind Data.List Data.List.NonEmpty Data.Maybe Data.Monoid Data.Ord Data.Proxy Data.Ratio Data.Semigroup Data.STRef Data.STRef.Lazy Data.STRef.Strict Data.String Data.Traversable Data.Tuple Data.Type.Bool Data.Type.Coercion Data.Type.Equality Data.Typeable Data.Typeable.Internal Data.Unique Data.Version Data.Void Data.Word Debug.Trace Foreign Foreign.C Foreign.C.Error Foreign.C.String Foreign.C.Types Foreign.Concurrent Foreign.ForeignPtr Foreign.ForeignPtr.Safe Foreign.ForeignPtr.Unsafe Foreign.Marshal Foreign.Marshal.Alloc Foreign.Marshal.Array Foreign.Marshal.Error Foreign.Marshal.Pool Foreign.Marshal.Safe Foreign.Marshal.Unsafe Foreign.Marshal.Utils Foreign.Ptr Foreign.Safe Foreign.StablePtr Foreign.Storable GHC.Arr GHC.Base GHC.Char GHC.Conc GHC.Conc.IO GHC.Conc.Signal GHC.Conc.Sync GHC.ConsoleHandler GHC.Constants GHC.Desugar GHC.Enum GHC.Environment GHC.Err GHC.Exception GHC.ExecutionStack GHC.ExecutionStack.Internal GHC.Exts GHC.Fingerprint GHC.Fingerprint.Type GHC.Float GHC.Float.ConversionUtils GHC.Float.RealFracMethods GHC.Foreign GHC.ForeignPtr GHC.GHCi GHC.Generics GHC.IO GHC.IO.Buffer GHC.IO.BufferedIO GHC.IO.Device GHC.IO.Encoding GHC.IO.Encoding.CodePage GHC.IO.Encoding.Failure GHC.IO.Encoding.Iconv GHC.IO.Encoding.Latin1 GHC.IO.Encoding.Types GHC.IO.Encoding.UTF16 GHC.IO.Encoding.UTF32 GHC.IO.Encoding.UTF8 GHC.IO.Exception GHC.IO.FD GHC.IO.Handle GHC.IO.Handle.FD GHC.IO.Handle.Internals GHC.IO.Handle.Text GHC.IO.Handle.Types GHC.IO.IOMode GHC.IO.Unsafe GHC.IOArray GHC.IORef GHC.Int GHC.List GHC.MVar GHC.Natural GHC.Num GHC.OldList GHC.OverloadedLabels GHC.PArr GHC.Pack GHC.Profiling GHC.Ptr GHC.Read GHC.Real GHC.RTS.Flags GHC.ST GHC.StaticPtr GHC.STRef GHC.Show GHC.Stable GHC.Stack GHC.Stack.CCS GHC.Stack.Types GHC.Stats GHC.Storable GHC.TopHandler GHC.TypeLits GHC.Unicode GHC.Weak GHC.Word Numeric Numeric.Natural Prelude System.CPUTime System.Console.GetOpt System.Environment System.Exit System.IO System.IO.Error System.IO.Unsafe System.Info System.Mem System.Mem.StableName System.Mem.Weak System.Posix.Internals System.Posix.Types System.Timeout Text.ParserCombinators.ReadP Text.ParserCombinators.ReadPrec Text.Printf Text.Read Text.Read.Lex Text.Show Text.Show.Functions Unsafe.Coerce GHC.Event hidden-modules: Control.Monad.ST.Imp Control.Monad.ST.Lazy.Imp Data.OldList Foreign.ForeignPtr.Imp System.Environment.ExecutablePath GHC.Event.Arr GHC.Event.Array GHC.Event.Clock GHC.Event.Control GHC.Event.EPoll GHC.Event.IntTable GHC.Event.Internal GHC.Event.KQueue GHC.Event.Manager GHC.Event.PSQ GHC.Event.Poll GHC.Event.Thread GHC.Event.TimerManager GHC.Event.Unique abi: 472df40e39128303d276cf121f250e89 trusted: False import-dirs: /opt/ghc/head/lib/ghc-7.11.20151213/base-4.9.0.0 library-dirs: /opt/ghc/head/lib/ghc-7.11.20151213/base-4.9.0.0 data-dir: /opt/ghc/head/share/x86_64-linux-ghc-7.11.20151213/base-4.9.0.0 hs-libraries: HSbase-4.9.0.0 include-dirs: /opt/ghc/head/lib/ghc-7.11.20151213/base-4.9.0.0/include includes: HsBase.h depends: ghc-prim-0.5.0.0 integer-gmp-1.0.0.0 rts haddock-interfaces: /opt/ghc/head/share/doc/ghc/html/libraries/base-4.9.0.0/base.haddock haddock-html: /opt/ghc/head/share/doc/ghc/html/libraries/base-4.9.0.0 --- name: integer-gmp version: 1.0.0.0 id: integer-gmp-1.0.0.0 key: integer-gmp-1.0.0.0 license: BSD3 maintainer: hvr@gnu.org synopsis: Integer library based on GMP category: Numeric, Algebra author: Herbert Valerio Riedel exposed: True exposed-modules: GHC.Integer GHC.Integer.Logarithms GHC.Integer.Logarithms.Internals GHC.Integer.GMP.Internals hidden-modules: GHC.Integer.Type abi: 32980bb533b4a3996f3424fd198cf767 trusted: False import-dirs: /opt/ghc/head/lib/ghc-7.11.20151213/integer-gmp-1.0.0.0 library-dirs: /opt/ghc/head/lib/ghc-7.11.20151213/integer-gmp-1.0.0.0 data-dir: /opt/ghc/head/share/x86_64-linux-ghc-7.11.20151213/integer-gmp-1.0.0.0 hs-libraries: HSinteger-gmp-1.0.0.0 extra-libraries: gmp include-dirs: /opt/ghc/head/lib/ghc-7.11.20151213/integer-gmp-1.0.0.0/include depends: ghc-prim-0.5.0.0 haddock-interfaces: /opt/ghc/head/share/doc/ghc/html/libraries/integer-gmp-1.0.0.0/integer-gmp.haddock haddock-html: /opt/ghc/head/share/doc/ghc/html/libraries/integer-gmp-1.0.0.0 --- name: ghc-prim version: 0.5.0.0 id: ghc-prim-0.5.0.0 key: ghc-prim-0.5.0.0 license: BSD3 maintainer: libraries@haskell.org synopsis: GHC primitives description: GHC primitives. category: GHC exposed: True exposed-modules: GHC.CString GHC.Classes GHC.Debug GHC.IntWord64 GHC.Magic GHC.PrimopWrappers GHC.Tuple GHC.Types GHC.Prim abi: 9f5ec1125ba73d164ce53f7b537009e8 trusted: False import-dirs: /opt/ghc/head/lib/ghc-7.11.20151213/ghc-prim-0.5.0.0 library-dirs: /opt/ghc/head/lib/ghc-7.11.20151213/ghc-prim-0.5.0.0 data-dir: /opt/ghc/head/share/x86_64-linux-ghc-7.11.20151213/ghc-prim-0.5.0.0 hs-libraries: HSghc-prim-0.5.0.0 depends: rts haddock-interfaces: /opt/ghc/head/share/doc/ghc/html/libraries/ghc-prim-0.5.0.0/ghc-prim.haddock haddock-html: /opt/ghc/head/share/doc/ghc/html/libraries/ghc-prim-0.5.0.0 --- name: rts version: 1.0 id: rts key: rts license: BSD3 maintainer: glasgow-haskell-users@haskell.org exposed: True abi: trusted: False library-dirs: /opt/ghc/head/lib/ghc-7.11.20151213/rts hs-libraries: HSrts Cffi extra-libraries: m rt dl include-dirs: /opt/ghc/head/lib/ghc-7.11.20151213/include includes: Stg.h ld-options: "-Wl,-u,ghczmprim_GHCziTypes_Izh_static_info" "-Wl,-u,ghczmprim_GHCziTypes_Czh_static_info" "-Wl,-u,ghczmprim_GHCziTypes_Fzh_static_info" "-Wl,-u,ghczmprim_GHCziTypes_Dzh_static_info" "-Wl,-u,base_GHCziPtr_Ptr_static_info" "-Wl,-u,ghczmprim_GHCziTypes_Wzh_static_info" "-Wl,-u,base_GHCziInt_I8zh_static_info" "-Wl,-u,base_GHCziInt_I16zh_static_info" "-Wl,-u,base_GHCziInt_I32zh_static_info" "-Wl,-u,base_GHCziInt_I64zh_static_info" "-Wl,-u,base_GHCziWord_W8zh_static_info" "-Wl,-u,base_GHCziWord_W16zh_static_info" "-Wl,-u,base_GHCziWord_W32zh_static_info" "-Wl,-u,base_GHCziWord_W64zh_static_info" "-Wl,-u,base_GHCziStable_StablePtr_static_info" "-Wl,-u,ghczmprim_GHCziTypes_Izh_con_info" "-Wl,-u,ghczmprim_GHCziTypes_Czh_con_info" "-Wl,-u,ghczmprim_GHCziTypes_Fzh_con_info" "-Wl,-u,ghczmprim_GHCziTypes_Dzh_con_info" "-Wl,-u,base_GHCziPtr_Ptr_con_info" "-Wl,-u,base_GHCziPtr_FunPtr_con_info" "-Wl,-u,base_GHCziStable_StablePtr_con_info" "-Wl,-u,ghczmprim_GHCziTypes_False_closure" "-Wl,-u,ghczmprim_GHCziTypes_True_closure" "-Wl,-u,base_GHCziPack_unpackCString_closure" "-Wl,-u,base_GHCziIOziException_stackOverflow_closure" "-Wl,-u,base_GHCziIOziException_heapOverflow_closure" "-Wl,-u,base_ControlziExceptionziBase_nonTermination_closure" "-Wl,-u,base_GHCziIOziException_blockedIndefinitelyOnMVar_closure" "-Wl,-u,base_GHCziIOziException_blockedIndefinitelyOnSTM_closure" "-Wl,-u,base_GHCziIOziException_allocationLimitExceeded_closure" "-Wl,-u,base_ControlziExceptionziBase_nestedAtomically_closure" "-Wl,-u,base_GHCziEventziThread_blockedOnBadFD_closure" "-Wl,-u,base_GHCziWeak_runFinalizzerBatch_closure" "-Wl,-u,base_GHCziTopHandler_flushStdHandles_closure" "-Wl,-u,base_GHCziTopHandler_runIO_closure" "-Wl,-u,base_GHCziTopHandler_runNonIO_closure" "-Wl,-u,base_GHCziConcziIO_ensureIOManagerIsRunning_closure" "-Wl,-u,base_GHCziConcziIO_ioManagerCapabilitiesChanged_closure" "-Wl,-u,base_GHCziConcziSync_runSparks_closure" "-Wl,-u,base_GHCziConcziSignal_runHandlersPtr_closure" stack-1.9.3.1/src/test/Stack/Untar/test1.tar.gz0000644000000000000000000000042113015755774017264 0ustar0000000000000000꣌WMj0`s fFRȾ^AvɢXU"JZl? OMB5"8㚔V+C^ؐ1LJɩj?b4HW߼4k#nb;Yrs4a}!ڼ:sO]ŋce}ބŸ=}.k )?3;̜ză?zNFqk/Ƴf?;\(stack-1.9.3.1/src/test/Stack/Untar/test2.tar.gz0000644000000000000000000000055713015755774017277 0ustar0000000000000000꣌WAN0E)r lXr@S%)TIEyQ,+/V]~-MQVKh)I@cRF%!h kIzg:/9h_=Yo)ġ {w&_|7hG\my>r_Uxv{r'|yO1Q?};XqpO`96bOGc֘vM@VиBJ)^Ka`kLw9HA.߶a:k    ? 4(