import Data.List ( nub, sortBy )

import Data.Ord ( comparing )

import Distribution.PackageDescription ( PackageDescription(), Executable(..) )

import Distribution.InstalledPackageInfo (sourcePackageId, installedPackageId)

import Distribution.Simple ( defaultMainWithHooks, UserHooks(..), simpleUserHooks )

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.Verbosity ( Verbosity )

import System.FilePath ( (</>) )

main :: IO ()

createDirectoryIfMissingVerbose verbosity True dir

withLibLBI pkg lbi $ \_ libcfg -> do

withExeLBI pkg lbi $ \exe clbi ->

, ""

, "deps :: [String]"

, "deps = " ++ (show $ formatdeps (transDeps libcfg clbi))

]

where

formatdeps = map formatone . sortBy (comparing unPackageName')

formatone p = unPackageName' p ++ "-" ++ showVersion (packageVersion p)

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 depedency hence is missing from allInstPkgsIdx. Filter that out.

handleDepClosureFailure unsatisfied =

error $

"Computation of transitive dependencies failed." ++

if null unsatisfied then "" else " Unresolved dependencies: " ++ show unsatisfied

ctx <- ask

-- TODO: it would be cool to defer these warnings until there's an

-- actual issue building the package.

case Map.toList mp of

[] -> Left (NoToolFound name (packageName p))

[_] -> Right mp

flagName, genPackageFlags,

condExecutables)

import qualified Distribution.PackageDescription as C

import Distribution.System (Platform)

import Distribution.Text (display)

import qualified Distribution.Version as C

-- worse case scenario is we build an extra package that wasn't

-- strictly needed.

gpdExes :: GenericPackageDescription -> [Text]

gpdPackages :: [GenericPackageDescription] -> Map PackageName Version

gpdPackages gpds = Map.fromList $

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 GHC.Conc (getNumProcessors)

import Lens.Micro (lens)

import Network.HTTP.Client (parseUrlThrow)

LCSNoConfig _ -> configNoLocalConfig stackRoot mresolver configArgs

LCSProject project -> loadHelper $ Just project

LCSNoProject -> loadHelper Nothing

(throwM (BadStackVersionException (configRequireStackVersion config)))

let mprojectRoot = fmap (\(_, fp, _) -> parent fp) mproject

]

where

go :: (T.Text -> NamedComponent)

-> [NamedComponent]

-- | Check if there are any duplicate package names and, if so, throw an

footerHelp =

let major = toCabalVersion

in commentHelp

[ "Control whether we use the GHC we find on the path"

, "system-ghc: true"

import qualified Data.Set as Set

import qualified Data.Text as T

import qualified Distribution.PackageDescription as C

import Options.Applicative

import Options.Applicative.Builder.Extra

import Stack.Config (getLocalPackages)

(C.genPackageFlags (lpvGPD lpv)))

$ Map.toList lpvs

flagString name fl =

flagEnabled name fl =

fromMaybe (C.flagDefault fl) $

Map.lookup (fromCabalFlagName (C.flagName fl)) $

return $

filter (input `isPrefixOf`) $

nubOrd $

Map.toList lpvs

import qualified Data.Text as T

import Data.Text.Encoding (decodeUtf8, decodeUtf8With)

import Data.Text.Encoding.Error (lenientDecode)

import Distribution.Compiler

import Distribution.ModuleName (ModuleName)

import qualified Distribution.ModuleName as Cabal

import Distribution.Simple.Utils

import Distribution.System (OS (..), Arch, Platform (..))

import qualified Distribution.Text as D

import qualified Distribution.Verbosity as D

import qualified Hpack

import qualified Hpack.Config as Hpack

import Path as FL

rawParseGPD :: BS.ByteString

-> Either PError ([PWarning], GenericPackageDescription)

rawParseGPD bs =

ParseFailed per -> Left per

ParseOk warnings gpkg -> Right (warnings,gpkg)

where

, packageLicense = license pkg

, packageDeps = deps

, packageFiles = pkgFiles

, packageGhcOptions = packageConfigGhcOptions packageConfig

, packageFlags = packageConfigFlags packageConfig

, packageDefaultFlags = M.fromList

[(fromCabalFlagName (flagName flag), flagDefault flag) | flag <- pkgFlags]

, packageAllDeps = S.fromList (M.keys deps)

, packageHasLibrary = maybe False (buildable . libBuildInfo) (library pkg)

, packageTests = M.fromList

, buildable (testBuildInfo t)]

, packageBenchmarks = S.fromList

, buildable (benchmarkBuildInfo biBuildInfo)]

, packageExes = S.fromList

, 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.

, fmap

(\exe ->

generate

(buildInfo exe))

(executables pkg)

, fmap

(\bench ->

generate

(benchmarkBuildInfo bench))

(benchmarks pkg)

, fmap

(\test ->

generate

(testBuildInfo test))

(testSuites pkg)]))

where

packageToolDependencies :: PackageDescription -> Map Text VersionRange

packageToolDependencies =

M.fromList .

buildTools) .

allBuildInfo'

-- | Get all dependencies of the package (buildable targets only).

-- | This is a copy-paste from Cabal's @allBuildInfo@ function, but with the

, True || buildable bi ]

++ [ bi | tst <- testSuites pkg_descr

, let bi = testBuildInfo tst

++ [ bi | tst <- benchmarks pkg_descr

, let bi = benchmarkBuildInfo tst

-- | Get all files referenced by the package.

packageDescModulesAndFiles

return (modules, files, dfiles, warnings)

where

libComponent = const CLib

asModuleAndFileMap label f lib = do

(a,b,c) <- f lib

return (M.singleton (label lib) a, M.singleton (label lib) b, c)

matchDirFileGlob_ :: (MonadLogger m, MonadIO m) => String -> String -> m [String]

matchDirFileGlob_ dir filepath = case parseFileGlob filepath of

"invalid file glob '" ++ filepath

++ "'. Wildcards '*' are only allowed in place of the file"

++ " name, not in the directory name or file extension."

dir <- asks (parent . fst)

(modules,files,warnings) <-

resolveFilesAndDeps

(dirs ++ [dir])

(bnames <> exposed)

haskellModuleExts

dir <- asks (parent . fst)

(modules,files,warnings) <-

resolveFilesAndDeps

(dirs ++ [dir])

(bnames <> exposed)

haskellModuleExts

dir <- asks (parent . fst)

(modules,files,warnings) <-

resolveFilesAndDeps

(dirs ++ [dir])

(map DotCabalModule (otherModules build) ++

[DotCabalMain (modulePath exe)])

resolvePackageDescription :: PackageConfig

-> GenericPackageDescription

-> PackageDescription

desc {library =

fmap (resolveConditions rc updateLibDeps) mlib

,executables =

(buildInfo exe) {targetBuildDepends = deps}}

updateTestDeps test deps =

test {testBuildInfo =

updateBenchmarkDeps benchmark deps =

benchmark {benchmarkBuildInfo =

-- | Make a map from a list of flag specifications.

resolveConditions rc addDeps (CondNode lib deps cs) = basic <> children

where basic = addDeps lib deps

children = mconcat (map apply cs)

if condSatisfied cond

then resolveConditions rc addDeps node

else maybe mempty (resolveConditions rc addDeps) mcs

:: (MonadIO m, MonadThrow m)

=> Path Abs File -> m PackageIdentifier

cabalFilePackageId fp = do

(toStackPI . D.package . D.packageDescription) pkgDescr

where

name' <- parsePackageNameFromString name

ver' <- parseVersionFromString (showVersion ver)

return (PackageIdentifier name' ver')

import Distribution.System (OS, Arch (..), Platform (..))

import qualified Distribution.System as Cabal

import Distribution.Text (simpleParse)

import Lens.Micro (set)

import Network.HTTP.Simple (getResponseBody, httpLBS, withResponse, getResponseStatusCode)

import Network.HTTP.Download

parseVersion $ T.drop 1 rawName

stackVersion :: Version