{-# LANGUAGE DataKinds #-}
{-# LANGUAGE PatternSynonyms #-}
{-# LANGUAGE RecordWildCards #-}
module Distribution.Client.CmdClean (cleanCommand, cleanAction) where
import Distribution.Client.Compat.Prelude
import Prelude ()
import Distribution.Client.Config
( defaultScriptBuildsDir
)
import Distribution.Client.DistDirLayout
( DistDirLayout (..)
, defaultDistDirLayout
)
import Distribution.Client.Errors
import Distribution.Client.ProjectConfig
( findProjectRoot
)
import Distribution.Client.ProjectFlags
( ProjectFlags (..)
, defaultProjectFlags
, projectFlagsOptions
, removeIgnoreProjectOption
)
import Distribution.Client.Setup
( GlobalFlags
)
import Distribution.Compat.Lens
( _1
, _2
)
import Distribution.Simple.Command
( CommandUI (..)
, OptionField
, ShowOrParseArgs
, liftOptionL
, option
)
import Distribution.Simple.Setup
( Flag
, falseArg
, flagToMaybe
, fromFlagOrDefault
, optionDistPref
, optionVerbosity
, toFlag
, pattern NoFlag
)
import Distribution.Simple.Utils
( dieWithException
, handleDoesNotExist
, info
, wrapText
)
import Distribution.System
( OS (Windows)
, buildOS
)
import Distribution.Utils.Path hiding
( (<.>)
, (</>)
)
import Distribution.Verbosity
( normal
)
import Control.Exception
( throw
)
import Control.Monad
( forM
, forM_
, mapM
)
import qualified Data.Set as Set
import System.Directory
( canonicalizePath
, doesDirectoryExist
, doesFileExist
, getDirectoryContents
, listDirectory
, removeDirectoryRecursive
, removeFile
, removePathForcibly
)
import System.FilePath
( (</>)
)
import System.IO.Error
( isPermissionError
)
import qualified System.Process as Process
data CleanFlags = CleanFlags
{ CleanFlags -> Flag Bool
cleanSaveConfig :: Flag Bool
, CleanFlags -> Flag Verbosity
cleanVerbosity :: Flag Verbosity
, CleanFlags -> Flag (SymbolicPath Pkg ('Dir Dist))
cleanDistDir :: Flag (SymbolicPath Pkg (Dir Dist))
}
deriving (CleanFlags -> CleanFlags -> Bool
(CleanFlags -> CleanFlags -> Bool)
-> (CleanFlags -> CleanFlags -> Bool) -> Eq CleanFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: CleanFlags -> CleanFlags -> Bool
== :: CleanFlags -> CleanFlags -> Bool
$c/= :: CleanFlags -> CleanFlags -> Bool
/= :: CleanFlags -> CleanFlags -> Bool
Eq)
defaultCleanFlags :: CleanFlags
defaultCleanFlags :: CleanFlags
defaultCleanFlags =
CleanFlags
{ cleanSaveConfig :: Flag Bool
cleanSaveConfig = Bool -> Flag Bool
forall a. a -> Flag a
toFlag Bool
False
, cleanVerbosity :: Flag Verbosity
cleanVerbosity = Verbosity -> Flag Verbosity
forall a. a -> Flag a
toFlag Verbosity
normal
, cleanDistDir :: Flag (SymbolicPath Pkg ('Dir Dist))
cleanDistDir = Flag (SymbolicPath Pkg ('Dir Dist))
forall a. Last a
NoFlag
}
cleanCommand :: CommandUI (ProjectFlags, CleanFlags)
cleanCommand :: CommandUI (ProjectFlags, CleanFlags)
cleanCommand =
CommandUI
{ commandName :: [Char]
commandName = [Char]
"v2-clean"
, commandSynopsis :: [Char]
commandSynopsis = [Char]
"Clean the package store and remove temporary files."
, commandUsage :: [Char] -> [Char]
commandUsage = \[Char]
pname ->
[Char]
"Usage: " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
pname [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
" new-clean [FLAGS]\n"
, commandDescription :: Maybe ([Char] -> [Char])
commandDescription = ([Char] -> [Char]) -> Maybe ([Char] -> [Char])
forall a. a -> Maybe a
Just (([Char] -> [Char]) -> Maybe ([Char] -> [Char]))
-> ([Char] -> [Char]) -> Maybe ([Char] -> [Char])
forall a b. (a -> b) -> a -> b
$ \[Char]
_ ->
[Char] -> [Char]
wrapText ([Char] -> [Char]) -> [Char] -> [Char]
forall a b. (a -> b) -> a -> b
$
[Char]
"Removes all temporary files created during the building process "
[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
"(.hi, .o, preprocessed sources, etc.) and also empties out the "
[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
"local caches (by default).\n\n"
, commandNotes :: Maybe ([Char] -> [Char])
commandNotes = Maybe ([Char] -> [Char])
forall a. Maybe a
Nothing
, commandDefaultFlags :: (ProjectFlags, CleanFlags)
commandDefaultFlags = (ProjectFlags
defaultProjectFlags, CleanFlags
defaultCleanFlags)
, commandOptions :: ShowOrParseArgs -> [OptionField (ProjectFlags, CleanFlags)]
commandOptions = \ShowOrParseArgs
showOrParseArgs ->
(OptionField ProjectFlags
-> OptionField (ProjectFlags, CleanFlags))
-> [OptionField ProjectFlags]
-> [OptionField (ProjectFlags, CleanFlags)]
forall a b. (a -> b) -> [a] -> [b]
map
(ALens' (ProjectFlags, CleanFlags) ProjectFlags
-> OptionField ProjectFlags
-> OptionField (ProjectFlags, CleanFlags)
forall b a. ALens' b a -> OptionField a -> OptionField b
liftOptionL ALens' (ProjectFlags, CleanFlags) ProjectFlags
forall a c b (f :: * -> *).
Functor f =>
LensLike f (a, c) (b, c) a b
_1)
([OptionField ProjectFlags] -> [OptionField ProjectFlags]
forall a. [OptionField a] -> [OptionField a]
removeIgnoreProjectOption (ShowOrParseArgs -> [OptionField ProjectFlags]
projectFlagsOptions ShowOrParseArgs
showOrParseArgs))
[OptionField (ProjectFlags, CleanFlags)]
-> [OptionField (ProjectFlags, CleanFlags)]
-> [OptionField (ProjectFlags, CleanFlags)]
forall a. [a] -> [a] -> [a]
++ (OptionField CleanFlags -> OptionField (ProjectFlags, CleanFlags))
-> [OptionField CleanFlags]
-> [OptionField (ProjectFlags, CleanFlags)]
forall a b. (a -> b) -> [a] -> [b]
map (ALens' (ProjectFlags, CleanFlags) CleanFlags
-> OptionField CleanFlags -> OptionField (ProjectFlags, CleanFlags)
forall b a. ALens' b a -> OptionField a -> OptionField b
liftOptionL ALens' (ProjectFlags, CleanFlags) CleanFlags
forall c a b (f :: * -> *).
Functor f =>
LensLike f (c, a) (c, b) a b
_2) (ShowOrParseArgs -> [OptionField CleanFlags]
cleanOptions ShowOrParseArgs
showOrParseArgs)
}
cleanOptions :: ShowOrParseArgs -> [OptionField CleanFlags]
cleanOptions :: ShowOrParseArgs -> [OptionField CleanFlags]
cleanOptions ShowOrParseArgs
showOrParseArgs =
[ (CleanFlags -> Flag Verbosity)
-> (Flag Verbosity -> CleanFlags -> CleanFlags)
-> OptionField CleanFlags
forall flags.
(flags -> Flag Verbosity)
-> (Flag Verbosity -> flags -> flags) -> OptionField flags
optionVerbosity
CleanFlags -> Flag Verbosity
cleanVerbosity
(\Flag Verbosity
v CleanFlags
flags -> CleanFlags
flags{cleanVerbosity = v})
, (CleanFlags -> Flag (SymbolicPath Pkg ('Dir Dist)))
-> (Flag (SymbolicPath Pkg ('Dir Dist))
-> CleanFlags -> CleanFlags)
-> ShowOrParseArgs
-> OptionField CleanFlags
forall flags.
(flags -> Flag (SymbolicPath Pkg ('Dir Dist)))
-> (Flag (SymbolicPath Pkg ('Dir Dist)) -> flags -> flags)
-> ShowOrParseArgs
-> OptionField flags
optionDistPref
CleanFlags -> Flag (SymbolicPath Pkg ('Dir Dist))
cleanDistDir
(\Flag (SymbolicPath Pkg ('Dir Dist))
dd CleanFlags
flags -> CleanFlags
flags{cleanDistDir = dd})
ShowOrParseArgs
showOrParseArgs
, [Char]
-> LFlags
-> [Char]
-> (CleanFlags -> Flag Bool)
-> (Flag Bool -> CleanFlags -> CleanFlags)
-> MkOptDescr
(CleanFlags -> Flag Bool)
(Flag Bool -> CleanFlags -> CleanFlags)
CleanFlags
-> OptionField CleanFlags
forall get set a.
[Char]
-> LFlags
-> [Char]
-> get
-> set
-> MkOptDescr get set a
-> OptionField a
option
[Char
's']
[[Char]
"save-config"]
[Char]
"Save configuration, only remove build artifacts"
CleanFlags -> Flag Bool
cleanSaveConfig
(\Flag Bool
sc CleanFlags
flags -> CleanFlags
flags{cleanSaveConfig = sc})
MkOptDescr
(CleanFlags -> Flag Bool)
(Flag Bool -> CleanFlags -> CleanFlags)
CleanFlags
forall a. MkOptDescr (a -> Flag Bool) (Flag Bool -> a -> a) a
falseArg
]
cleanAction :: (ProjectFlags, CleanFlags) -> [String] -> GlobalFlags -> IO ()
cleanAction :: (ProjectFlags, CleanFlags) -> LFlags -> GlobalFlags -> IO ()
cleanAction (ProjectFlags{Flag Bool
Flag [Char]
flagProjectDir :: Flag [Char]
flagProjectFile :: Flag [Char]
flagIgnoreProject :: Flag Bool
flagIgnoreProject :: ProjectFlags -> Flag Bool
flagProjectDir :: ProjectFlags -> Flag [Char]
flagProjectFile :: ProjectFlags -> Flag [Char]
..}, CleanFlags{Flag Bool
Flag Verbosity
Flag (SymbolicPath Pkg ('Dir Dist))
cleanSaveConfig :: CleanFlags -> Flag Bool
cleanVerbosity :: CleanFlags -> Flag Verbosity
cleanDistDir :: CleanFlags -> Flag (SymbolicPath Pkg ('Dir Dist))
cleanSaveConfig :: Flag Bool
cleanVerbosity :: Flag Verbosity
cleanDistDir :: Flag (SymbolicPath Pkg ('Dir Dist))
..}) LFlags
extraArgs GlobalFlags
_ = do
let verbosity :: Verbosity
verbosity = Verbosity -> Flag Verbosity -> Verbosity
forall a. a -> Flag a -> a
fromFlagOrDefault Verbosity
normal Flag Verbosity
cleanVerbosity
saveConfig :: Bool
saveConfig = Bool -> Flag Bool -> Bool
forall a. a -> Flag a -> a
fromFlagOrDefault Bool
False Flag Bool
cleanSaveConfig
mdistDirectory :: Maybe [Char]
mdistDirectory = (SymbolicPath Pkg ('Dir Dist) -> [Char])
-> Maybe (SymbolicPath Pkg ('Dir Dist)) -> Maybe [Char]
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap SymbolicPath Pkg ('Dir Dist) -> [Char]
forall (allowAbsolute :: AllowAbsolute) from (to :: FileOrDir).
SymbolicPathX allowAbsolute from to -> [Char]
getSymbolicPath (Maybe (SymbolicPath Pkg ('Dir Dist)) -> Maybe [Char])
-> Maybe (SymbolicPath Pkg ('Dir Dist)) -> Maybe [Char]
forall a b. (a -> b) -> a -> b
$ Flag (SymbolicPath Pkg ('Dir Dist))
-> Maybe (SymbolicPath Pkg ('Dir Dist))
forall a. Flag a -> Maybe a
flagToMaybe Flag (SymbolicPath Pkg ('Dir Dist))
cleanDistDir
mprojectDir :: Maybe [Char]
mprojectDir = Flag [Char] -> Maybe [Char]
forall a. Flag a -> Maybe a
flagToMaybe Flag [Char]
flagProjectDir
mprojectFile :: Maybe [Char]
mprojectFile = Flag [Char] -> Maybe [Char]
forall a. Flag a -> Maybe a
flagToMaybe Flag [Char]
flagProjectFile
notScripts <- ([Char] -> IO Bool) -> LFlags -> IO LFlags
forall (m :: * -> *) a.
Applicative m =>
(a -> m Bool) -> [a] -> m [a]
filterM ((Bool -> Bool) -> IO Bool -> IO Bool
forall a b. (a -> b) -> IO a -> IO b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Bool -> Bool
not (IO Bool -> IO Bool) -> ([Char] -> IO Bool) -> [Char] -> IO Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> IO Bool
doesFileExist) LFlags
extraArgs
unless (null notScripts) $
dieWithException verbosity $
CleanAction notScripts
projectRoot <- either throwIO return =<< findProjectRoot verbosity mprojectDir mprojectFile
let distLayout = ProjectRoot -> Maybe [Char] -> Maybe [Char] -> DistDirLayout
defaultDistDirLayout ProjectRoot
projectRoot Maybe [Char]
mdistDirectory Maybe [Char]
forall a. Maybe a
Nothing
when (null extraArgs || isJust mdistDirectory) $ do
if saveConfig
then do
let buildRoot = DistDirLayout -> [Char]
distBuildRootDirectory DistDirLayout
distLayout
buildRootExists <- doesDirectoryExist buildRoot
when buildRootExists $ do
info verbosity ("Deleting build root (" ++ buildRoot ++ ")")
handleDoesNotExist () $ removeDirectoryRecursive buildRoot
else do
let distRoot = DistDirLayout -> [Char]
distDirectory DistDirLayout
distLayout
info verbosity ("Deleting dist-newstyle (" ++ distRoot ++ ")")
handleDoesNotExist () $ do
if buildOS == Windows
then do
void $
Process.createProcess_ "attrib" $
Process.shell $
"attrib -s -h -r " <> distRoot <> "\\*.* /s /d"
catch
(removePathForcibly distRoot)
(\IOException
e -> if IOException -> Bool
isPermissionError IOException
e then [Char] -> IO ()
removePathForcibly [Char]
distRoot else IOException -> IO ()
forall a e. (HasCallStack, Exception e) => e -> a
throw IOException
e)
else removeDirectoryRecursive distRoot
removeEnvFiles $ distProjectRootDirectory distLayout
toClean <- Set.fromList <$> mapM canonicalizePath extraArgs
cacheDir <- defaultScriptBuildsDir
existsCD <- doesDirectoryExist cacheDir
caches <- if existsCD then listDirectory cacheDir else return []
paths <- fmap concat . forM caches $ \[Char]
cache -> do
let locFile :: [Char]
locFile = [Char]
cacheDir [Char] -> [Char] -> [Char]
</> [Char]
cache [Char] -> [Char] -> [Char]
</> [Char]
"scriptlocation"
exists <- [Char] -> IO Bool
doesFileExist [Char]
locFile
if exists then pure . (,) (cacheDir </> cache) <$> readFile locFile else return []
forM_ paths $ \([Char]
cache, [Char]
script) -> do
exists <- [Char] -> IO Bool
doesFileExist [Char]
script
when (not exists || script `Set.member` toClean) $ do
info verbosity ("Deleting cache (" ++ cache ++ ") for script (" ++ script ++ ")")
removeDirectoryRecursive cache
removeEnvFiles :: FilePath -> IO ()
removeEnvFiles :: [Char] -> IO ()
removeEnvFiles [Char]
dir =
(([Char] -> IO ()) -> LFlags -> IO ()
forall (t :: * -> *) (f :: * -> *) a b.
(Foldable t, Applicative f) =>
(a -> f b) -> t a -> f ()
traverse_ ([Char] -> IO ()
removeFile ([Char] -> IO ()) -> ([Char] -> [Char]) -> [Char] -> IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ([Char]
dir [Char] -> [Char] -> [Char]
</>)) (LFlags -> IO ()) -> (LFlags -> LFlags) -> LFlags -> IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ([Char] -> Bool) -> LFlags -> LFlags
forall a. (a -> Bool) -> [a] -> [a]
filter (([Char]
".ghc.environment" [Char] -> [Char] -> Bool
forall a. Eq a => a -> a -> Bool
==) ([Char] -> Bool) -> ([Char] -> [Char]) -> [Char] -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> [Char] -> [Char]
forall a. Int -> [a] -> [a]
take Int
16))
(LFlags -> IO ()) -> IO LFlags -> IO ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< [Char] -> IO LFlags
getDirectoryContents [Char]
dir