{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE TemplateHaskell #-}
{-# LANGUAGE TupleSections #-}
{-# LANGUAGE TypeFamilies #-}
module Path.IO
(
createDir,
createDirIfMissing,
ensureDir,
removeDir,
removeDirRecur,
removePathForcibly,
renameDir,
renamePath,
listDir,
listDirRel,
listDirRecur,
listDirRecurRel,
copyDirRecur,
copyDirRecur',
WalkAction (..),
walkDir,
walkDirRel,
walkDirAccum,
walkDirAccumRel,
getCurrentDir,
setCurrentDir,
withCurrentDir,
getHomeDir,
getAppUserDataDir,
getUserDocsDir,
getTempDir,
D.XdgDirectory (..),
getXdgDir,
D.XdgDirectoryList (..),
getXdgDirList,
AnyPath (..),
resolveFile,
resolveFile',
resolveDir,
resolveDir',
removeFile,
renameFile,
copyFile,
getFileSize,
findExecutable,
findFile,
findFiles,
findFilesWith,
createFileLink,
createDirLink,
removeDirLink,
getSymlinkTarget,
isSymlink,
withTempFile,
withTempDir,
withSystemTempFile,
withSystemTempDir,
openTempFile,
openBinaryTempFile,
createTempDir,
doesPathExist,
doesFileExist,
doesDirExist,
isLocationOccupied,
forgivingAbsence,
ignoringAbsence,
D.Permissions,
D.emptyPermissions,
D.readable,
D.writable,
D.executable,
D.searchable,
D.setOwnerReadable,
D.setOwnerWritable,
D.setOwnerExecutable,
D.setOwnerSearchable,
getPermissions,
setPermissions,
copyPermissions,
getAccessTime,
setAccessTime,
setModificationTime,
getModificationTime,
)
where
import Control.Arrow ((***))
import Control.Monad
import Control.Monad.Catch
import Control.Monad.IO.Class (MonadIO (..))
import Control.Monad.Trans.Class (lift)
import Control.Monad.Trans.Maybe (MaybeT (..), runMaybeT)
import Control.Monad.Trans.Writer.Strict (WriterT, execWriterT, tell)
import Data.DList qualified as DList
import Data.Either (lefts, rights)
import Data.Kind (Type)
import Data.List ((\\))
import Data.Set qualified as S
import Data.Time (UTCTime)
import Path
import System.Directory qualified as D
import System.FilePath qualified as F
import System.IO (Handle)
import System.IO.Error (isDoesNotExistError)
import System.IO.Temp qualified as T
import System.PosixCompat.Files qualified as P
createDir :: (MonadIO m) => Path b Dir -> m ()
createDir :: forall (m :: * -> *) b. MonadIO m => Path b Dir -> m ()
createDir = (FilePath -> IO ()) -> Path b Dir -> m ()
forall (m :: * -> *) a b t.
MonadIO m =>
(FilePath -> IO a) -> Path b t -> m a
liftD FilePath -> IO ()
D.createDirectory
createDirIfMissing ::
(MonadIO m) =>
Bool ->
Path b Dir ->
m ()
createDirIfMissing :: forall (m :: * -> *) b. MonadIO m => Bool -> Path b Dir -> m ()
createDirIfMissing Bool
p = (FilePath -> IO ()) -> Path b Dir -> m ()
forall (m :: * -> *) a b t.
MonadIO m =>
(FilePath -> IO a) -> Path b t -> m a
liftD (Bool -> FilePath -> IO ()
D.createDirectoryIfMissing Bool
p)
ensureDir :: (MonadIO m) => Path b Dir -> m ()
ensureDir :: forall (m :: * -> *) b. MonadIO m => Path b Dir -> m ()
ensureDir = Bool -> Path b Dir -> m ()
forall (m :: * -> *) b. MonadIO m => Bool -> Path b Dir -> m ()
createDirIfMissing Bool
True
removeDir :: (MonadIO m) => Path b Dir -> m ()
removeDir :: forall (m :: * -> *) b. MonadIO m => Path b Dir -> m ()
removeDir = (FilePath -> IO ()) -> Path b Dir -> m ()
forall (m :: * -> *) a b t.
MonadIO m =>
(FilePath -> IO a) -> Path b t -> m a
liftD FilePath -> IO ()
D.removeDirectory
removeDirRecur :: (MonadIO m) => Path b Dir -> m ()
removeDirRecur :: forall (m :: * -> *) b. MonadIO m => Path b Dir -> m ()
removeDirRecur = (FilePath -> IO ()) -> Path b Dir -> m ()
forall (m :: * -> *) a b t.
MonadIO m =>
(FilePath -> IO a) -> Path b t -> m a
liftD FilePath -> IO ()
D.removeDirectoryRecursive
removePathForcibly :: (MonadIO m) => Path b t -> m ()
removePathForcibly :: forall (m :: * -> *) b t. MonadIO m => Path b t -> m ()
removePathForcibly = (FilePath -> IO ()) -> Path b t -> m ()
forall (m :: * -> *) a b t.
MonadIO m =>
(FilePath -> IO a) -> Path b t -> m a
liftD FilePath -> IO ()
D.removePathForcibly
renameDir ::
(MonadIO m) =>
Path b0 Dir ->
Path b1 Dir ->
m ()
renameDir :: forall (m :: * -> *) b0 b1.
MonadIO m =>
Path b0 Dir -> Path b1 Dir -> m ()
renameDir = (FilePath -> FilePath -> IO ())
-> Path b0 Dir -> Path b1 Dir -> m ()
forall (m :: * -> *) a b0 t0 b1 t1.
MonadIO m =>
(FilePath -> FilePath -> IO a) -> Path b0 t0 -> Path b1 t1 -> m a
liftD2 FilePath -> FilePath -> IO ()
D.renameDirectory
renamePath :: (MonadIO m) => Path b0 t -> Path b1 t -> m ()
renamePath :: forall (m :: * -> *) b0 t b1.
MonadIO m =>
Path b0 t -> Path b1 t -> m ()
renamePath = (FilePath -> FilePath -> IO ()) -> Path b0 t -> Path b1 t -> m ()
forall (m :: * -> *) a b0 t0 b1 t1.
MonadIO m =>
(FilePath -> FilePath -> IO a) -> Path b0 t0 -> Path b1 t1 -> m a
liftD2 FilePath -> FilePath -> IO ()
D.renamePath
listDir ::
(MonadIO m) =>
Path b Dir ->
m ([Path Abs Dir], [Path Abs File])
listDir :: forall (m :: * -> *) b.
MonadIO m =>
Path b Dir -> m ([Path Abs Dir], [Path Abs File])
listDir Path b Dir
path = do
Path Abs Dir
bpath <- Path b Dir -> m (AbsPath (Path b Dir))
forall path (m :: * -> *).
(AnyPath path, MonadIO m) =>
path -> m (AbsPath path)
forall (m :: * -> *).
MonadIO m =>
Path b Dir -> m (AbsPath (Path b Dir))
makeAbsolute Path b Dir
path
([Path Rel Dir]
subdirs, [Path Rel File]
files) <- Path Abs Dir -> m ([Path Rel Dir], [Path Rel File])
forall (m :: * -> *) b.
MonadIO m =>
Path b Dir -> m ([Path Rel Dir], [Path Rel File])
listDirRel Path Abs Dir
bpath
([Path Abs Dir], [Path Abs File])
-> m ([Path Abs Dir], [Path Abs File])
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return
( (Path Abs Dir
bpath </>) (Path Rel Dir -> Path Abs Dir) -> [Path Rel Dir] -> [Path Abs Dir]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Path Rel Dir]
subdirs,
(Path Abs Dir
bpath </>) (Path Rel File -> Path Abs File)
-> [Path Rel File] -> [Path Abs File]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Path Rel File]
files
)
listDirRel ::
(MonadIO m) =>
Path b Dir ->
m ([Path Rel Dir], [Path Rel File])
listDirRel :: forall (m :: * -> *) b.
MonadIO m =>
Path b Dir -> m ([Path Rel Dir], [Path Rel File])
listDirRel Path b Dir
path = IO ([Path Rel Dir], [Path Rel File])
-> m ([Path Rel Dir], [Path Rel File])
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO ([Path Rel Dir], [Path Rel File])
-> m ([Path Rel Dir], [Path Rel File]))
-> IO ([Path Rel Dir], [Path Rel File])
-> m ([Path Rel Dir], [Path Rel File])
forall a b. (a -> b) -> a -> b
$ do
[FilePath]
raw <- (FilePath -> IO [FilePath]) -> Path b Dir -> IO [FilePath]
forall (m :: * -> *) a b t.
MonadIO m =>
(FilePath -> IO a) -> Path b t -> m a
liftD FilePath -> IO [FilePath]
D.getDirectoryContents Path b Dir
path
[Either (Path Rel Dir) (Path Rel File)]
items <- [FilePath]
-> (FilePath -> IO (Either (Path Rel Dir) (Path Rel File)))
-> IO [Either (Path Rel Dir) (Path Rel File)]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
t a -> (a -> m b) -> m (t b)
forM ([FilePath]
raw [FilePath] -> [FilePath] -> [FilePath]
forall a. Eq a => [a] -> [a] -> [a]
\\ [FilePath
".", FilePath
".."]) ((FilePath -> IO (Either (Path Rel Dir) (Path Rel File)))
-> IO [Either (Path Rel Dir) (Path Rel File)])
-> (FilePath -> IO (Either (Path Rel Dir) (Path Rel File)))
-> IO [Either (Path Rel Dir) (Path Rel File)]
forall a b. (a -> b) -> a -> b
$ \FilePath
item -> do
Bool
isDir <- IO Bool -> IO Bool
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (FilePath -> IO Bool
D.doesDirectoryExist (FilePath -> IO Bool) -> FilePath -> IO Bool
forall a b. (a -> b) -> a -> b
$ Path b Dir -> FilePath
forall b t. Path b t -> FilePath
toFilePath Path b Dir
path FilePath -> FilePath -> FilePath
F.</> FilePath
item)
if Bool
isDir
then Path Rel Dir -> Either (Path Rel Dir) (Path Rel File)
forall a b. a -> Either a b
Left (Path Rel Dir -> Either (Path Rel Dir) (Path Rel File))
-> IO (Path Rel Dir) -> IO (Either (Path Rel Dir) (Path Rel File))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> FilePath -> IO (Path Rel Dir)
forall (m :: * -> *). MonadThrow m => FilePath -> m (Path Rel Dir)
parseRelDir FilePath
item
else Path Rel File -> Either (Path Rel Dir) (Path Rel File)
forall a b. b -> Either a b
Right (Path Rel File -> Either (Path Rel Dir) (Path Rel File))
-> IO (Path Rel File) -> IO (Either (Path Rel Dir) (Path Rel File))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> FilePath -> IO (Path Rel File)
forall (m :: * -> *). MonadThrow m => FilePath -> m (Path Rel File)
parseRelFile FilePath
item
([Path Rel Dir], [Path Rel File])
-> IO ([Path Rel Dir], [Path Rel File])
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ([Either (Path Rel Dir) (Path Rel File)] -> [Path Rel Dir]
forall a b. [Either a b] -> [a]
lefts [Either (Path Rel Dir) (Path Rel File)]
items, [Either (Path Rel Dir) (Path Rel File)] -> [Path Rel File]
forall a b. [Either a b] -> [b]
rights [Either (Path Rel Dir) (Path Rel File)]
items)
listDirRecur ::
(MonadIO m) =>
Path b Dir ->
m ([Path Abs Dir], [Path Abs File])
listDirRecur :: forall (m :: * -> *) b.
MonadIO m =>
Path b Dir -> m ([Path Abs Dir], [Path Abs File])
listDirRecur Path b Dir
dir =
(DList (Path Abs Dir) -> [Path Abs Dir]
forall a. DList a -> [a]
DList.toList (DList (Path Abs Dir) -> [Path Abs Dir])
-> (DList (Path Abs File) -> [Path Abs File])
-> (DList (Path Abs Dir), DList (Path Abs File))
-> ([Path Abs Dir], [Path Abs File])
forall b c b' c'. (b -> c) -> (b' -> c') -> (b, b') -> (c, c')
forall (a :: * -> * -> *) b c b' c'.
Arrow a =>
a b c -> a b' c' -> a (b, b') (c, c')
*** DList (Path Abs File) -> [Path Abs File]
forall a. DList a -> [a]
DList.toList)
((DList (Path Abs Dir), DList (Path Abs File))
-> ([Path Abs Dir], [Path Abs File]))
-> m (DList (Path Abs Dir), DList (Path Abs File))
-> m ([Path Abs Dir], [Path Abs File])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe
(Path Abs Dir
-> [Path Abs Dir] -> [Path Abs File] -> m (WalkAction Abs))
-> (Path Abs Dir
-> [Path Abs Dir]
-> [Path Abs File]
-> m (DList (Path Abs Dir), DList (Path Abs File)))
-> Path b Dir
-> m (DList (Path Abs Dir), DList (Path Abs File))
forall (m :: * -> *) o b.
(MonadIO m, Monoid o) =>
Maybe
(Path Abs Dir
-> [Path Abs Dir] -> [Path Abs File] -> m (WalkAction Abs))
-> (Path Abs Dir -> [Path Abs Dir] -> [Path Abs File] -> m o)
-> Path b Dir
-> m o
walkDirAccum ((Path Abs Dir
-> [Path Abs Dir] -> [Path Abs File] -> m (WalkAction Abs))
-> Maybe
(Path Abs Dir
-> [Path Abs Dir] -> [Path Abs File] -> m (WalkAction Abs))
forall a. a -> Maybe a
Just Path Abs Dir
-> [Path Abs Dir] -> [Path Abs File] -> m (WalkAction Abs)
forall {f :: * -> *} {p} {b} {p}.
MonadIO f =>
p -> [Path b Dir] -> p -> f (WalkAction b)
excludeSymlinks) Path Abs Dir
-> [Path Abs Dir]
-> [Path Abs File]
-> m (DList (Path Abs Dir), DList (Path Abs File))
forall {m :: * -> *} {p} {a} {a}.
Monad m =>
p -> [a] -> [a] -> m (DList a, DList a)
writer Path b Dir
dir
where
excludeSymlinks :: p -> [Path b Dir] -> p -> f (WalkAction b)
excludeSymlinks p
_ [Path b Dir]
subdirs p
_ =
[Path b Dir] -> WalkAction b
forall b. [Path b Dir] -> WalkAction b
WalkExclude ([Path b Dir] -> WalkAction b)
-> f [Path b Dir] -> f (WalkAction b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Path b Dir -> f Bool) -> [Path b Dir] -> f [Path b Dir]
forall (m :: * -> *) a.
Applicative m =>
(a -> m Bool) -> [a] -> m [a]
filterM Path b Dir -> f Bool
forall (m :: * -> *) b t. MonadIO m => Path b t -> m Bool
isSymlink [Path b Dir]
subdirs
writer :: p -> [a] -> [a] -> m (DList a, DList a)
writer p
_ [a]
ds [a]
fs =
(DList a, DList a) -> m (DList a, DList a)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return
( [a] -> DList a
forall a. [a] -> DList a
DList.fromList [a]
ds,
[a] -> DList a
forall a. [a] -> DList a
DList.fromList [a]
fs
)
listDirRecurRel ::
(MonadIO m) =>
Path b Dir ->
m ([Path Rel Dir], [Path Rel File])
listDirRecurRel :: forall (m :: * -> *) b.
MonadIO m =>
Path b Dir -> m ([Path Rel Dir], [Path Rel File])
listDirRecurRel Path b Dir
dir =
(DList (Path Rel Dir) -> [Path Rel Dir]
forall a. DList a -> [a]
DList.toList (DList (Path Rel Dir) -> [Path Rel Dir])
-> (DList (Path Rel File) -> [Path Rel File])
-> (DList (Path Rel Dir), DList (Path Rel File))
-> ([Path Rel Dir], [Path Rel File])
forall b c b' c'. (b -> c) -> (b' -> c') -> (b, b') -> (c, c')
forall (a :: * -> * -> *) b c b' c'.
Arrow a =>
a b c -> a b' c' -> a (b, b') (c, c')
*** DList (Path Rel File) -> [Path Rel File]
forall a. DList a -> [a]
DList.toList)
((DList (Path Rel Dir), DList (Path Rel File))
-> ([Path Rel Dir], [Path Rel File]))
-> m (DList (Path Rel Dir), DList (Path Rel File))
-> m ([Path Rel Dir], [Path Rel File])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe
(Path Rel Dir
-> [Path Rel Dir] -> [Path Rel File] -> m (WalkAction Rel))
-> (Path Rel Dir
-> [Path Rel Dir]
-> [Path Rel File]
-> m (DList (Path Rel Dir), DList (Path Rel File)))
-> Path b Dir
-> m (DList (Path Rel Dir), DList (Path Rel File))
forall (m :: * -> *) o b.
(MonadIO m, Monoid o) =>
Maybe
(Path Rel Dir
-> [Path Rel Dir] -> [Path Rel File] -> m (WalkAction Rel))
-> (Path Rel Dir -> [Path Rel Dir] -> [Path Rel File] -> m o)
-> Path b Dir
-> m o
walkDirAccumRel ((Path Rel Dir
-> [Path Rel Dir] -> [Path Rel File] -> m (WalkAction Rel))
-> Maybe
(Path Rel Dir
-> [Path Rel Dir] -> [Path Rel File] -> m (WalkAction Rel))
forall a. a -> Maybe a
Just Path Rel Dir
-> [Path Rel Dir] -> [Path Rel File] -> m (WalkAction Rel)
excludeSymlinks) Path Rel Dir
-> [Path Rel Dir]
-> [Path Rel File]
-> m (DList (Path Rel Dir), DList (Path Rel File))
forall {m :: * -> *} {b} {t} {t}.
Monad m =>
Path b Dir
-> [Path Rel t]
-> [Path Rel t]
-> m (DList (Path b t), DList (Path b t))
writer Path b Dir
dir
where
excludeSymlinks :: Path Rel Dir
-> [Path Rel Dir] -> [Path Rel File] -> m (WalkAction Rel)
excludeSymlinks Path Rel Dir
tdir [Path Rel Dir]
subdirs [Path Rel File]
_ =
[Path Rel Dir] -> WalkAction Rel
forall b. [Path b Dir] -> WalkAction b
WalkExclude ([Path Rel Dir] -> WalkAction Rel)
-> m [Path Rel Dir] -> m (WalkAction Rel)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Path Rel Dir -> m Bool) -> [Path Rel Dir] -> m [Path Rel Dir]
forall (m :: * -> *) a.
Applicative m =>
(a -> m Bool) -> [a] -> m [a]
filterM (Path b Dir -> m Bool
forall (m :: * -> *) b t. MonadIO m => Path b t -> m Bool
isSymlink (Path b Dir -> m Bool)
-> (Path Rel Dir -> Path b Dir) -> Path Rel Dir -> m Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Path b Dir
dir </>) (Path Rel Dir -> Path b Dir)
-> (Path Rel Dir -> Path Rel Dir) -> Path Rel Dir -> Path b Dir
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Path Rel Dir
tdir </>)) [Path Rel Dir]
subdirs
writer :: Path b Dir
-> [Path Rel t]
-> [Path Rel t]
-> m (DList (Path b t), DList (Path b t))
writer Path b Dir
tdir [Path Rel t]
ds [Path Rel t]
fs =
(DList (Path b t), DList (Path b t))
-> m (DList (Path b t), DList (Path b t))
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return
( [Path b t] -> DList (Path b t)
forall a. [a] -> DList a
DList.fromList ((Path b Dir
tdir </>) (Path Rel t -> Path b t) -> [Path Rel t] -> [Path b t]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Path Rel t]
ds),
[Path b t] -> DList (Path b t)
forall a. [a] -> DList a
DList.fromList ((Path b Dir
tdir </>) (Path Rel t -> Path b t) -> [Path Rel t] -> [Path b t]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Path Rel t]
fs)
)
copyDirRecur ::
(MonadIO m) =>
Path b0 Dir ->
Path b1 Dir ->
m ()
copyDirRecur :: forall (m :: * -> *) b0 b1.
MonadIO m =>
Path b0 Dir -> Path b1 Dir -> m ()
copyDirRecur = Bool -> Path b0 Dir -> Path b1 Dir -> m ()
forall (m :: * -> *) b0 b1.
MonadIO m =>
Bool -> Path b0 Dir -> Path b1 Dir -> m ()
copyDirRecurGen Bool
True
copyDirRecur' ::
(MonadIO m) =>
Path b0 Dir ->
Path b1 Dir ->
m ()
copyDirRecur' :: forall (m :: * -> *) b0 b1.
MonadIO m =>
Path b0 Dir -> Path b1 Dir -> m ()
copyDirRecur' = Bool -> Path b0 Dir -> Path b1 Dir -> m ()
forall (m :: * -> *) b0 b1.
MonadIO m =>
Bool -> Path b0 Dir -> Path b1 Dir -> m ()
copyDirRecurGen Bool
False
copyDirRecurGen ::
(MonadIO m) =>
Bool ->
Path b0 Dir ->
Path b1 Dir ->
m ()
copyDirRecurGen :: forall (m :: * -> *) b0 b1.
MonadIO m =>
Bool -> Path b0 Dir -> Path b1 Dir -> m ()
copyDirRecurGen Bool
preserveDirPermissions Path b0 Dir
src Path b1 Dir
dest = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Path Abs Dir
bsrc <- Path b0 Dir -> IO (AbsPath (Path b0 Dir))
forall path (m :: * -> *).
(AnyPath path, MonadIO m) =>
path -> m (AbsPath path)
forall (m :: * -> *).
MonadIO m =>
Path b0 Dir -> m (AbsPath (Path b0 Dir))
makeAbsolute Path b0 Dir
src
Path Abs Dir
bdest <- Path b1 Dir -> IO (AbsPath (Path b1 Dir))
forall path (m :: * -> *).
(AnyPath path, MonadIO m) =>
path -> m (AbsPath path)
forall (m :: * -> *).
MonadIO m =>
Path b1 Dir -> m (AbsPath (Path b1 Dir))
makeAbsolute Path b1 Dir
dest
([Path Abs Dir]
dirs, [Path Abs File]
files) <- Path Abs Dir -> IO ([Path Abs Dir], [Path Abs File])
forall (m :: * -> *) b.
MonadIO m =>
Path b Dir -> m ([Path Abs Dir], [Path Abs File])
listDirRecur Path Abs Dir
bsrc
let swapParent ::
Path Abs Dir ->
Path Abs Dir ->
Path Abs t ->
IO (Path Abs t)
swapParent :: forall t.
Path Abs Dir -> Path Abs Dir -> Path Abs t -> IO (Path Abs t)
swapParent Path Abs Dir
old Path Abs Dir
new Path Abs t
path =
(Path Abs Dir
new </>)
(Path Rel t -> Path Abs t) -> IO (Path Rel t) -> IO (Path Abs t)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Path Abs Dir -> Path Abs t -> IO (Path Rel t)
forall (m :: * -> *) b t.
MonadThrow m =>
Path b Dir -> Path b t -> m (Path Rel t)
stripProperPrefix Path Abs Dir
old Path Abs t
path
Path Abs Dir -> IO ()
forall (m :: * -> *) b. MonadIO m => Path b Dir -> m ()
ensureDir Path Abs Dir
bdest
[IO ()]
copyPermissionsIOs <- [Path Abs Dir] -> (Path Abs Dir -> IO (IO ())) -> IO [IO ()]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
t a -> (a -> m b) -> m (t b)
forM [Path Abs Dir]
dirs ((Path Abs Dir -> IO (IO ())) -> IO [IO ()])
-> (Path Abs Dir -> IO (IO ())) -> IO [IO ()]
forall a b. (a -> b) -> a -> b
$ \Path Abs Dir
srcDir -> do
Path Abs Dir
destDir <- Path Abs Dir -> Path Abs Dir -> Path Abs Dir -> IO (Path Abs Dir)
forall t.
Path Abs Dir -> Path Abs Dir -> Path Abs t -> IO (Path Abs t)
swapParent Path Abs Dir
bsrc Path Abs Dir
bdest Path Abs Dir
srcDir
Bool
dirIsSymlink <- Path Abs Dir -> IO Bool
forall (m :: * -> *) b t. MonadIO m => Path b t -> m Bool
isSymlink Path Abs Dir
srcDir
if Bool
dirIsSymlink
then do
FilePath
target <- Path Abs Dir -> IO FilePath
forall (m :: * -> *) b t. MonadIO m => Path b t -> m FilePath
getSymlinkTarget Path Abs Dir
srcDir
FilePath -> FilePath -> IO ()
D.createDirectoryLink FilePath
target (FilePath -> IO ()) -> FilePath -> IO ()
forall a b. (a -> b) -> a -> b
$
Path Abs Dir -> FilePath
forall b t. Path b t -> FilePath
toFilePath' Path Abs Dir
destDir
else Path Abs Dir -> IO ()
forall (m :: * -> *) b. MonadIO m => Path b Dir -> m ()
ensureDir Path Abs Dir
destDir
IO () -> IO (IO ())
forall a. a -> IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (IO () -> IO (IO ())) -> IO () -> IO (IO ())
forall a b. (a -> b) -> a -> b
$ IO () -> IO ()
ignoringIOErrors (Path Abs Dir -> Path Abs Dir -> IO ()
forall (m :: * -> *) b0 t0 b1 t1.
MonadIO m =>
Path b0 t0 -> Path b1 t1 -> m ()
copyPermissions Path Abs Dir
srcDir Path Abs Dir
destDir)
[Path Abs File] -> (Path Abs File -> IO ()) -> IO ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
t a -> (a -> m b) -> m ()
forM_ [Path Abs File]
files ((Path Abs File -> IO ()) -> IO ())
-> (Path Abs File -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Path Abs File
srcFile -> do
Path Abs File
destFile <- Path Abs Dir -> Path Abs Dir -> Path Abs File -> IO (Path Abs File)
forall t.
Path Abs Dir -> Path Abs Dir -> Path Abs t -> IO (Path Abs t)
swapParent Path Abs Dir
bsrc Path Abs Dir
bdest Path Abs File
srcFile
Bool
fileIsSymlink <- Path Abs File -> IO Bool
forall (m :: * -> *) b t. MonadIO m => Path b t -> m Bool
isSymlink Path Abs File
srcFile
if Bool
fileIsSymlink
then do
FilePath
target <- Path Abs File -> IO FilePath
forall (m :: * -> *) b t. MonadIO m => Path b t -> m FilePath
getSymlinkTarget Path Abs File
srcFile
FilePath -> FilePath -> IO ()
D.createFileLink FilePath
target (Path Abs File -> FilePath
forall b t. Path b t -> FilePath
toFilePath Path Abs File
destFile)
else Path Abs File -> Path Abs File -> IO ()
forall (m :: * -> *) b0 b1.
MonadIO m =>
Path b0 File -> Path b1 File -> m ()
copyFile Path Abs File
srcFile Path Abs File
destFile
Bool -> IO () -> IO ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when Bool
preserveDirPermissions (IO () -> IO ()) -> IO () -> IO ()
forall a b. (a -> b) -> a -> b
$ do
IO () -> IO ()
ignoringIOErrors (Path Abs Dir -> Path Abs Dir -> IO ()
forall (m :: * -> *) b0 t0 b1 t1.
MonadIO m =>
Path b0 t0 -> Path b1 t1 -> m ()
copyPermissions Path Abs Dir
bsrc Path Abs Dir
bdest)
[IO ()] -> IO ()
forall (t :: * -> *) (m :: * -> *) a.
(Foldable t, Monad m) =>
t (m a) -> m ()
sequence_ [IO ()]
copyPermissionsIOs
data WalkAction b
=
WalkFinish
|
WalkExclude [Path b Dir]
deriving (WalkAction b -> WalkAction b -> Bool
(WalkAction b -> WalkAction b -> Bool)
-> (WalkAction b -> WalkAction b -> Bool) -> Eq (WalkAction b)
forall b. WalkAction b -> WalkAction b -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall b. WalkAction b -> WalkAction b -> Bool
== :: WalkAction b -> WalkAction b -> Bool
$c/= :: forall b. WalkAction b -> WalkAction b -> Bool
/= :: WalkAction b -> WalkAction b -> Bool
Eq, Int -> WalkAction b -> FilePath -> FilePath
[WalkAction b] -> FilePath -> FilePath
WalkAction b -> FilePath
(Int -> WalkAction b -> FilePath -> FilePath)
-> (WalkAction b -> FilePath)
-> ([WalkAction b] -> FilePath -> FilePath)
-> Show (WalkAction b)
forall b. Int -> WalkAction b -> FilePath -> FilePath
forall b. [WalkAction b] -> FilePath -> FilePath
forall b. WalkAction b -> FilePath
forall a.
(Int -> a -> FilePath -> FilePath)
-> (a -> FilePath) -> ([a] -> FilePath -> FilePath) -> Show a
$cshowsPrec :: forall b. Int -> WalkAction b -> FilePath -> FilePath
showsPrec :: Int -> WalkAction b -> FilePath -> FilePath
$cshow :: forall b. WalkAction b -> FilePath
show :: WalkAction b -> FilePath
$cshowList :: forall b. [WalkAction b] -> FilePath -> FilePath
showList :: [WalkAction b] -> FilePath -> FilePath
Show)
walkDir ::
(MonadIO m) =>
(Path Abs Dir -> [Path Abs Dir] -> [Path Abs File] -> m (WalkAction Abs)) ->
Path b Dir ->
m ()
walkDir :: forall (m :: * -> *) b.
MonadIO m =>
(Path Abs Dir
-> [Path Abs Dir] -> [Path Abs File] -> m (WalkAction Abs))
-> Path b Dir -> m ()
walkDir Path Abs Dir
-> [Path Abs Dir] -> [Path Abs File] -> m (WalkAction Abs)
handler Path b Dir
topdir =
m (Maybe ()) -> m ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (m (Maybe ()) -> m ()) -> m (Maybe ()) -> m ()
forall a b. (a -> b) -> a -> b
$
Path b Dir -> m (AbsPath (Path b Dir))
forall path (m :: * -> *).
(AnyPath path, MonadIO m) =>
path -> m (AbsPath path)
forall (m :: * -> *).
MonadIO m =>
Path b Dir -> m (AbsPath (Path b Dir))
makeAbsolute Path b Dir
topdir m (Path Abs Dir) -> (Path Abs Dir -> m (Maybe ())) -> m (Maybe ())
forall a b. m a -> (a -> m b) -> m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Set (DeviceID, FileID) -> Path Abs Dir -> m (Maybe ())
walkAvoidLoop Set (DeviceID, FileID)
forall a. Set a
S.empty
where
walkAvoidLoop :: Set (DeviceID, FileID) -> Path Abs Dir -> m (Maybe ())
walkAvoidLoop Set (DeviceID, FileID)
traversed Path Abs Dir
curdir = do
Maybe (Set (DeviceID, FileID))
mRes <- Set (DeviceID, FileID)
-> Path Abs Dir -> m (Maybe (Set (DeviceID, FileID)))
forall {m :: * -> *}.
MonadIO m =>
Set (DeviceID, FileID)
-> Path Abs Dir -> m (Maybe (Set (DeviceID, FileID)))
checkLoop Set (DeviceID, FileID)
traversed Path Abs Dir
curdir
case Maybe (Set (DeviceID, FileID))
mRes of
Maybe (Set (DeviceID, FileID))
Nothing -> Maybe () -> m (Maybe ())
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe () -> m (Maybe ())) -> Maybe () -> m (Maybe ())
forall a b. (a -> b) -> a -> b
$ () -> Maybe ()
forall a. a -> Maybe a
Just ()
Just Set (DeviceID, FileID)
traversed' -> Set (DeviceID, FileID) -> Path Abs Dir -> m (Maybe ())
walktree Set (DeviceID, FileID)
traversed' Path Abs Dir
curdir
walktree :: Set (DeviceID, FileID) -> Path Abs Dir -> m (Maybe ())
walktree Set (DeviceID, FileID)
traversed Path Abs Dir
curdir = do
([Path Abs Dir]
subdirs, [Path Abs File]
files) <- Path Abs Dir -> m ([Path Abs Dir], [Path Abs File])
forall (m :: * -> *) b.
MonadIO m =>
Path b Dir -> m ([Path Abs Dir], [Path Abs File])
listDir Path Abs Dir
curdir
WalkAction Abs
action <- Path Abs Dir
-> [Path Abs Dir] -> [Path Abs File] -> m (WalkAction Abs)
handler Path Abs Dir
curdir [Path Abs Dir]
subdirs [Path Abs File]
files
case WalkAction Abs
action of
WalkAction Abs
WalkFinish -> Maybe () -> m (Maybe ())
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe ()
forall a. Maybe a
Nothing
WalkExclude [Path Abs Dir]
xdirs ->
case [Path Abs Dir]
subdirs [Path Abs Dir] -> [Path Abs Dir] -> [Path Abs Dir]
forall a. Eq a => [a] -> [a] -> [a]
\\ [Path Abs Dir]
xdirs of
[] -> Maybe () -> m (Maybe ())
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe () -> m (Maybe ())) -> Maybe () -> m (Maybe ())
forall a b. (a -> b) -> a -> b
$ () -> Maybe ()
forall a. a -> Maybe a
Just ()
[Path Abs Dir]
ds ->
MaybeT m () -> m (Maybe ())
forall (m :: * -> *) a. MaybeT m a -> m (Maybe a)
runMaybeT (MaybeT m () -> m (Maybe ())) -> MaybeT m () -> m (Maybe ())
forall a b. (a -> b) -> a -> b
$
(Path Abs Dir -> MaybeT m ()) -> [Path Abs Dir] -> MaybeT m ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_
(m (Maybe ()) -> MaybeT m ()
forall (m :: * -> *) a. m (Maybe a) -> MaybeT m a
MaybeT (m (Maybe ()) -> MaybeT m ())
-> (Path Abs Dir -> m (Maybe ())) -> Path Abs Dir -> MaybeT m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Set (DeviceID, FileID) -> Path Abs Dir -> m (Maybe ())
walkAvoidLoop Set (DeviceID, FileID)
traversed)
[Path Abs Dir]
ds
checkLoop :: Set (DeviceID, FileID)
-> Path Abs Dir -> m (Maybe (Set (DeviceID, FileID)))
checkLoop Set (DeviceID, FileID)
traversed Path Abs Dir
dir = do
FileStatus
st <- IO FileStatus -> m FileStatus
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO FileStatus -> m FileStatus) -> IO FileStatus -> m FileStatus
forall a b. (a -> b) -> a -> b
$ FilePath -> IO FileStatus
P.getFileStatus (Path Abs Dir -> FilePath
fromAbsDir Path Abs Dir
dir)
let ufid :: (DeviceID, FileID)
ufid = (FileStatus -> DeviceID
P.deviceID FileStatus
st, FileStatus -> FileID
P.fileID FileStatus
st)
Maybe (Set (DeviceID, FileID))
-> m (Maybe (Set (DeviceID, FileID)))
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe (Set (DeviceID, FileID))
-> m (Maybe (Set (DeviceID, FileID))))
-> Maybe (Set (DeviceID, FileID))
-> m (Maybe (Set (DeviceID, FileID)))
forall a b. (a -> b) -> a -> b
$
if (DeviceID, FileID) -> Set (DeviceID, FileID) -> Bool
forall a. Ord a => a -> Set a -> Bool
S.member (DeviceID, FileID)
ufid Set (DeviceID, FileID)
traversed
then Maybe (Set (DeviceID, FileID))
forall a. Maybe a
Nothing
else Set (DeviceID, FileID) -> Maybe (Set (DeviceID, FileID))
forall a. a -> Maybe a
Just ((DeviceID, FileID)
-> Set (DeviceID, FileID) -> Set (DeviceID, FileID)
forall a. Ord a => a -> Set a -> Set a
S.insert (DeviceID, FileID)
ufid Set (DeviceID, FileID)
traversed)
walkDirRel ::
(MonadIO m) =>
( Path Rel Dir ->
[Path Rel Dir] ->
[Path Rel File] ->
m (WalkAction Rel)
) ->
Path b Dir ->
m ()
walkDirRel :: forall (m :: * -> *) b.
MonadIO m =>
(Path Rel Dir
-> [Path Rel Dir] -> [Path Rel File] -> m (WalkAction Rel))
-> Path b Dir -> m ()
walkDirRel Path Rel Dir
-> [Path Rel Dir] -> [Path Rel File] -> m (WalkAction Rel)
handler Path b Dir
topdir' = do
Path Abs Dir
topdir <- Path b Dir -> m (AbsPath (Path b Dir))
forall path (m :: * -> *).
(AnyPath path, MonadIO m) =>
path -> m (AbsPath path)
forall (m :: * -> *).
MonadIO m =>
Path b Dir -> m (AbsPath (Path b Dir))
makeAbsolute Path b Dir
topdir'
let walkAvoidLoop :: Set (DeviceID, FileID) -> Path Rel Dir -> m (Maybe ())
walkAvoidLoop Set (DeviceID, FileID)
traversed Path Rel Dir
curdir = do
Maybe (Set (DeviceID, FileID))
mRes <- Set (DeviceID, FileID)
-> Path Abs Dir -> m (Maybe (Set (DeviceID, FileID)))
forall {m :: * -> *}.
MonadIO m =>
Set (DeviceID, FileID)
-> Path Abs Dir -> m (Maybe (Set (DeviceID, FileID)))
checkLoop Set (DeviceID, FileID)
traversed (Path Abs Dir
topdir Path Abs Dir -> Path Rel Dir -> Path Abs Dir
forall b t. Path b Dir -> Path Rel t -> Path b t
</> Path Rel Dir
curdir)
case Maybe (Set (DeviceID, FileID))
mRes of
Maybe (Set (DeviceID, FileID))
Nothing -> Maybe () -> m (Maybe ())
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe () -> m (Maybe ())) -> Maybe () -> m (Maybe ())
forall a b. (a -> b) -> a -> b
$ () -> Maybe ()
forall a. a -> Maybe a
Just ()
Just Set (DeviceID, FileID)
traversed' -> Set (DeviceID, FileID) -> Path Rel Dir -> m (Maybe ())
walktree Set (DeviceID, FileID)
traversed' Path Rel Dir
curdir
walktree :: Set (DeviceID, FileID) -> Path Rel Dir -> m (Maybe ())
walktree Set (DeviceID, FileID)
traversed Path Rel Dir
curdir = do
([Path Rel Dir]
subdirs, [Path Rel File]
files) <- Path Abs Dir -> m ([Path Rel Dir], [Path Rel File])
forall (m :: * -> *) b.
MonadIO m =>
Path b Dir -> m ([Path Rel Dir], [Path Rel File])
listDirRel (Path Abs Dir
topdir Path Abs Dir -> Path Rel Dir -> Path Abs Dir
forall b t. Path b Dir -> Path Rel t -> Path b t
</> Path Rel Dir
curdir)
WalkAction Rel
action <- Path Rel Dir
-> [Path Rel Dir] -> [Path Rel File] -> m (WalkAction Rel)
handler Path Rel Dir
curdir [Path Rel Dir]
subdirs [Path Rel File]
files
case WalkAction Rel
action of
WalkAction Rel
WalkFinish -> Maybe () -> m (Maybe ())
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe ()
forall a. Maybe a
Nothing
WalkExclude [Path Rel Dir]
xdirs ->
case [Path Rel Dir]
subdirs [Path Rel Dir] -> [Path Rel Dir] -> [Path Rel Dir]
forall a. Eq a => [a] -> [a] -> [a]
\\ [Path Rel Dir]
xdirs of
[] -> Maybe () -> m (Maybe ())
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe () -> m (Maybe ())) -> Maybe () -> m (Maybe ())
forall a b. (a -> b) -> a -> b
$ () -> Maybe ()
forall a. a -> Maybe a
Just ()
[Path Rel Dir]
ds ->
MaybeT m () -> m (Maybe ())
forall (m :: * -> *) a. MaybeT m a -> m (Maybe a)
runMaybeT (MaybeT m () -> m (Maybe ())) -> MaybeT m () -> m (Maybe ())
forall a b. (a -> b) -> a -> b
$
(Path Rel Dir -> MaybeT m ()) -> [Path Rel Dir] -> MaybeT m ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_
(m (Maybe ()) -> MaybeT m ()
forall (m :: * -> *) a. m (Maybe a) -> MaybeT m a
MaybeT (m (Maybe ()) -> MaybeT m ())
-> (Path Rel Dir -> m (Maybe ())) -> Path Rel Dir -> MaybeT m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Set (DeviceID, FileID) -> Path Rel Dir -> m (Maybe ())
walkAvoidLoop Set (DeviceID, FileID)
traversed)
((Path Rel Dir
curdir </>) (Path Rel Dir -> Path Rel Dir) -> [Path Rel Dir] -> [Path Rel Dir]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Path Rel Dir]
ds)
checkLoop :: Set (DeviceID, FileID)
-> Path Abs Dir -> m (Maybe (Set (DeviceID, FileID)))
checkLoop Set (DeviceID, FileID)
traversed Path Abs Dir
dir = do
FileStatus
st <- IO FileStatus -> m FileStatus
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO FileStatus -> m FileStatus) -> IO FileStatus -> m FileStatus
forall a b. (a -> b) -> a -> b
$ FilePath -> IO FileStatus
P.getFileStatus (Path Abs Dir -> FilePath
fromAbsDir Path Abs Dir
dir)
let ufid :: (DeviceID, FileID)
ufid = (FileStatus -> DeviceID
P.deviceID FileStatus
st, FileStatus -> FileID
P.fileID FileStatus
st)
Maybe (Set (DeviceID, FileID))
-> m (Maybe (Set (DeviceID, FileID)))
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe (Set (DeviceID, FileID))
-> m (Maybe (Set (DeviceID, FileID))))
-> Maybe (Set (DeviceID, FileID))
-> m (Maybe (Set (DeviceID, FileID)))
forall a b. (a -> b) -> a -> b
$
if (DeviceID, FileID) -> Set (DeviceID, FileID) -> Bool
forall a. Ord a => a -> Set a -> Bool
S.member (DeviceID, FileID)
ufid Set (DeviceID, FileID)
traversed
then Maybe (Set (DeviceID, FileID))
forall a. Maybe a
Nothing
else Set (DeviceID, FileID) -> Maybe (Set (DeviceID, FileID))
forall a. a -> Maybe a
Just ((DeviceID, FileID)
-> Set (DeviceID, FileID) -> Set (DeviceID, FileID)
forall a. Ord a => a -> Set a -> Set a
S.insert (DeviceID, FileID)
ufid Set (DeviceID, FileID)
traversed)
m (Maybe ()) -> m ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (Set (DeviceID, FileID) -> Path Rel Dir -> m (Maybe ())
walkAvoidLoop Set (DeviceID, FileID)
forall a. Set a
S.empty $(mkRelDir "."))
walkDirAccum ::
(MonadIO m, Monoid o) =>
Maybe
(Path Abs Dir -> [Path Abs Dir] -> [Path Abs File] -> m (WalkAction Abs)) ->
(Path Abs Dir -> [Path Abs Dir] -> [Path Abs File] -> m o) ->
Path b Dir ->
m o
walkDirAccum :: forall (m :: * -> *) o b.
(MonadIO m, Monoid o) =>
Maybe
(Path Abs Dir
-> [Path Abs Dir] -> [Path Abs File] -> m (WalkAction Abs))
-> (Path Abs Dir -> [Path Abs Dir] -> [Path Abs File] -> m o)
-> Path b Dir
-> m o
walkDirAccum = ((Path Abs Dir
-> [Path Abs Dir]
-> [Path Abs File]
-> WriterT o m (WalkAction Abs))
-> Path b Dir -> WriterT o m ())
-> Maybe
(Path Abs Dir
-> [Path Abs Dir] -> [Path Abs File] -> m (WalkAction Abs))
-> (Path Abs Dir -> [Path Abs Dir] -> [Path Abs File] -> m o)
-> Path b Dir
-> m o
forall (m :: * -> *) o a b.
(MonadIO m, Monoid o) =>
((Path a Dir
-> [Path a Dir] -> [Path a File] -> WriterT o m (WalkAction a))
-> Path b Dir -> WriterT o m ())
-> Maybe
(Path a Dir -> [Path a Dir] -> [Path a File] -> m (WalkAction a))
-> (Path a Dir -> [Path a Dir] -> [Path a File] -> m o)
-> Path b Dir
-> m o
walkDirAccumWith (Path Abs Dir
-> [Path Abs Dir]
-> [Path Abs File]
-> WriterT o m (WalkAction Abs))
-> Path b Dir -> WriterT o m ()
forall (m :: * -> *) b.
MonadIO m =>
(Path Abs Dir
-> [Path Abs Dir] -> [Path Abs File] -> m (WalkAction Abs))
-> Path b Dir -> m ()
walkDir
walkDirAccumRel ::
(MonadIO m, Monoid o) =>
Maybe
(Path Rel Dir -> [Path Rel Dir] -> [Path Rel File] -> m (WalkAction Rel)) ->
(Path Rel Dir -> [Path Rel Dir] -> [Path Rel File] -> m o) ->
Path b Dir ->
m o
walkDirAccumRel :: forall (m :: * -> *) o b.
(MonadIO m, Monoid o) =>
Maybe
(Path Rel Dir
-> [Path Rel Dir] -> [Path Rel File] -> m (WalkAction Rel))
-> (Path Rel Dir -> [Path Rel Dir] -> [Path Rel File] -> m o)
-> Path b Dir
-> m o
walkDirAccumRel = ((Path Rel Dir
-> [Path Rel Dir]
-> [Path Rel File]
-> WriterT o m (WalkAction Rel))
-> Path b Dir -> WriterT o m ())
-> Maybe
(Path Rel Dir
-> [Path Rel Dir] -> [Path Rel File] -> m (WalkAction Rel))
-> (Path Rel Dir -> [Path Rel Dir] -> [Path Rel File] -> m o)
-> Path b Dir
-> m o
forall (m :: * -> *) o a b.
(MonadIO m, Monoid o) =>
((Path a Dir
-> [Path a Dir] -> [Path a File] -> WriterT o m (WalkAction a))
-> Path b Dir -> WriterT o m ())
-> Maybe
(Path a Dir -> [Path a Dir] -> [Path a File] -> m (WalkAction a))
-> (Path a Dir -> [Path a Dir] -> [Path a File] -> m o)
-> Path b Dir
-> m o
walkDirAccumWith (Path Rel Dir
-> [Path Rel Dir]
-> [Path Rel File]
-> WriterT o m (WalkAction Rel))
-> Path b Dir -> WriterT o m ()
forall (m :: * -> *) b.
MonadIO m =>
(Path Rel Dir
-> [Path Rel Dir] -> [Path Rel File] -> m (WalkAction Rel))
-> Path b Dir -> m ()
walkDirRel
walkDirAccumWith ::
(MonadIO m, Monoid o) =>
( ( Path a Dir ->
[Path a Dir] ->
[Path a File] ->
WriterT o m (WalkAction a)
) ->
Path b Dir ->
WriterT o m ()
) ->
Maybe (Path a Dir -> [Path a Dir] -> [Path a File] -> m (WalkAction a)) ->
(Path a Dir -> [Path a Dir] -> [Path a File] -> m o) ->
Path b Dir ->
m o
walkDirAccumWith :: forall (m :: * -> *) o a b.
(MonadIO m, Monoid o) =>
((Path a Dir
-> [Path a Dir] -> [Path a File] -> WriterT o m (WalkAction a))
-> Path b Dir -> WriterT o m ())
-> Maybe
(Path a Dir -> [Path a Dir] -> [Path a File] -> m (WalkAction a))
-> (Path a Dir -> [Path a Dir] -> [Path a File] -> m o)
-> Path b Dir
-> m o
walkDirAccumWith (Path a Dir
-> [Path a Dir] -> [Path a File] -> WriterT o m (WalkAction a))
-> Path b Dir -> WriterT o m ()
walkF Maybe
(Path a Dir -> [Path a Dir] -> [Path a File] -> m (WalkAction a))
dHandler Path a Dir -> [Path a Dir] -> [Path a File] -> m o
writer Path b Dir
topdir =
WriterT o m () -> m o
forall (m :: * -> *) w a. Monad m => WriterT w m a -> m w
execWriterT ((Path a Dir
-> [Path a Dir] -> [Path a File] -> WriterT o m (WalkAction a))
-> Path b Dir -> WriterT o m ()
walkF Path a Dir
-> [Path a Dir] -> [Path a File] -> WriterT o m (WalkAction a)
handler Path b Dir
topdir)
where
handler :: Path a Dir
-> [Path a Dir] -> [Path a File] -> WriterT o m (WalkAction a)
handler Path a Dir
dir [Path a Dir]
subdirs [Path a File]
files = do
o
res <- m o -> WriterT o m o
forall (m :: * -> *) a. Monad m => m a -> WriterT o m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m o -> WriterT o m o) -> m o -> WriterT o m o
forall a b. (a -> b) -> a -> b
$ Path a Dir -> [Path a Dir] -> [Path a File] -> m o
writer Path a Dir
dir [Path a Dir]
subdirs [Path a File]
files
o -> WriterT o m ()
forall (m :: * -> *) w. Monad m => w -> WriterT w m ()
tell o
res
case Maybe
(Path a Dir -> [Path a Dir] -> [Path a File] -> m (WalkAction a))
dHandler of
Just Path a Dir -> [Path a Dir] -> [Path a File] -> m (WalkAction a)
h -> m (WalkAction a) -> WriterT o m (WalkAction a)
forall (m :: * -> *) a. Monad m => m a -> WriterT o m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m (WalkAction a) -> WriterT o m (WalkAction a))
-> m (WalkAction a) -> WriterT o m (WalkAction a)
forall a b. (a -> b) -> a -> b
$ Path a Dir -> [Path a Dir] -> [Path a File] -> m (WalkAction a)
h Path a Dir
dir [Path a Dir]
subdirs [Path a File]
files
Maybe
(Path a Dir -> [Path a Dir] -> [Path a File] -> m (WalkAction a))
Nothing -> WalkAction a -> WriterT o m (WalkAction a)
forall a. a -> WriterT o m a
forall (m :: * -> *) a. Monad m => a -> m a
return ([Path a Dir] -> WalkAction a
forall b. [Path b Dir] -> WalkAction b
WalkExclude [])
getCurrentDir :: (MonadIO m) => m (Path Abs Dir)
getCurrentDir :: forall (m :: * -> *). MonadIO m => m (Path Abs Dir)
getCurrentDir = IO (Path Abs Dir) -> m (Path Abs Dir)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Path Abs Dir) -> m (Path Abs Dir))
-> IO (Path Abs Dir) -> m (Path Abs Dir)
forall a b. (a -> b) -> a -> b
$ IO FilePath
D.getCurrentDirectory IO FilePath -> (FilePath -> IO (Path Abs Dir)) -> IO (Path Abs Dir)
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FilePath -> IO (Path Abs Dir)
forall (m :: * -> *). MonadThrow m => FilePath -> m (Path Abs Dir)
parseAbsDir
setCurrentDir :: (MonadIO m) => Path b Dir -> m ()
setCurrentDir :: forall (m :: * -> *) b. MonadIO m => Path b Dir -> m ()
setCurrentDir = (FilePath -> IO ()) -> Path b Dir -> m ()
forall (m :: * -> *) a b t.
MonadIO m =>
(FilePath -> IO a) -> Path b t -> m a
liftD FilePath -> IO ()
D.setCurrentDirectory
withCurrentDir ::
(MonadIO m, MonadMask m) =>
Path b Dir ->
m a ->
m a
withCurrentDir :: forall (m :: * -> *) b a.
(MonadIO m, MonadMask m) =>
Path b Dir -> m a -> m a
withCurrentDir Path b Dir
dir m a
action =
m (Path Abs Dir)
-> (Path Abs Dir -> m ()) -> (Path Abs Dir -> m a) -> m a
forall (m :: * -> *) a c b.
(HasCallStack, MonadMask m) =>
m a -> (a -> m c) -> (a -> m b) -> m b
bracket m (Path Abs Dir)
forall (m :: * -> *). MonadIO m => m (Path Abs Dir)
getCurrentDir Path Abs Dir -> m ()
forall (m :: * -> *) b. MonadIO m => Path b Dir -> m ()
setCurrentDir ((Path Abs Dir -> m a) -> m a) -> (Path Abs Dir -> m a) -> m a
forall a b. (a -> b) -> a -> b
$ m a -> Path Abs Dir -> m a
forall a b. a -> b -> a
const (Path b Dir -> m ()
forall (m :: * -> *) b. MonadIO m => Path b Dir -> m ()
setCurrentDir Path b Dir
dir m () -> m a -> m a
forall a b. m a -> m b -> m b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> m a
action)
getHomeDir :: (MonadIO m) => m (Path Abs Dir)
getHomeDir :: forall (m :: * -> *). MonadIO m => m (Path Abs Dir)
getHomeDir = IO FilePath -> m FilePath
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO IO FilePath
D.getHomeDirectory m FilePath -> (FilePath -> m (Path Abs Dir)) -> m (Path Abs Dir)
forall a b. m a -> (a -> m b) -> m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FilePath -> m (Path Abs Dir)
forall (m :: * -> *). MonadIO m => FilePath -> m (Path Abs Dir)
resolveDir'
getAppUserDataDir ::
(MonadIO m) =>
String ->
m (Path Abs Dir)
getAppUserDataDir :: forall (m :: * -> *). MonadIO m => FilePath -> m (Path Abs Dir)
getAppUserDataDir = IO (Path Abs Dir) -> m (Path Abs Dir)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Path Abs Dir) -> m (Path Abs Dir))
-> (FilePath -> IO (Path Abs Dir)) -> FilePath -> m (Path Abs Dir)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (IO FilePath -> (FilePath -> IO (Path Abs Dir)) -> IO (Path Abs Dir)
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FilePath -> IO (Path Abs Dir)
forall (m :: * -> *). MonadThrow m => FilePath -> m (Path Abs Dir)
parseAbsDir) (IO FilePath -> IO (Path Abs Dir))
-> (FilePath -> IO FilePath) -> FilePath -> IO (Path Abs Dir)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. FilePath -> IO FilePath
D.getAppUserDataDirectory
getUserDocsDir :: (MonadIO m) => m (Path Abs Dir)
getUserDocsDir :: forall (m :: * -> *). MonadIO m => m (Path Abs Dir)
getUserDocsDir = IO (Path Abs Dir) -> m (Path Abs Dir)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Path Abs Dir) -> m (Path Abs Dir))
-> IO (Path Abs Dir) -> m (Path Abs Dir)
forall a b. (a -> b) -> a -> b
$ IO FilePath
D.getUserDocumentsDirectory IO FilePath -> (FilePath -> IO (Path Abs Dir)) -> IO (Path Abs Dir)
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FilePath -> IO (Path Abs Dir)
forall (m :: * -> *). MonadThrow m => FilePath -> m (Path Abs Dir)
parseAbsDir
getTempDir :: (MonadIO m) => m (Path Abs Dir)
getTempDir :: forall (m :: * -> *). MonadIO m => m (Path Abs Dir)
getTempDir = IO FilePath -> m FilePath
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO IO FilePath
D.getTemporaryDirectory m FilePath -> (FilePath -> m (Path Abs Dir)) -> m (Path Abs Dir)
forall a b. m a -> (a -> m b) -> m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FilePath -> m (Path Abs Dir)
forall (m :: * -> *). MonadIO m => FilePath -> m (Path Abs Dir)
resolveDir'
getXdgDir ::
(MonadIO m) =>
D.XdgDirectory ->
Maybe (Path Rel Dir) ->
m (Path Abs Dir)
getXdgDir :: forall (m :: * -> *).
MonadIO m =>
XdgDirectory -> Maybe (Path Rel Dir) -> m (Path Abs Dir)
getXdgDir XdgDirectory
xdgDir Maybe (Path Rel Dir)
suffix =
IO (Path Abs Dir) -> m (Path Abs Dir)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Path Abs Dir) -> m (Path Abs Dir))
-> IO (Path Abs Dir) -> m (Path Abs Dir)
forall a b. (a -> b) -> a -> b
$ (XdgDirectory -> FilePath -> IO FilePath
D.getXdgDirectory XdgDirectory
xdgDir (FilePath -> IO FilePath) -> FilePath -> IO FilePath
forall a b. (a -> b) -> a -> b
$ FilePath
-> (Path Rel Dir -> FilePath) -> Maybe (Path Rel Dir) -> FilePath
forall b a. b -> (a -> b) -> Maybe a -> b
maybe FilePath
"" Path Rel Dir -> FilePath
forall b t. Path b t -> FilePath
toFilePath Maybe (Path Rel Dir)
suffix) IO FilePath -> (FilePath -> IO (Path Abs Dir)) -> IO (Path Abs Dir)
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FilePath -> IO (Path Abs Dir)
forall (m :: * -> *). MonadThrow m => FilePath -> m (Path Abs Dir)
parseAbsDir
getXdgDirList ::
(MonadIO m) =>
D.XdgDirectoryList ->
m [Path Abs Dir]
getXdgDirList :: forall (m :: * -> *).
MonadIO m =>
XdgDirectoryList -> m [Path Abs Dir]
getXdgDirList XdgDirectoryList
xdgDirList =
IO [Path Abs Dir] -> m [Path Abs Dir]
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (XdgDirectoryList -> IO [FilePath]
D.getXdgDirectoryList XdgDirectoryList
xdgDirList IO [FilePath]
-> ([FilePath] -> IO [Path Abs Dir]) -> IO [Path Abs Dir]
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (FilePath -> IO (Path Abs Dir)) -> [FilePath] -> IO [Path Abs Dir]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM FilePath -> IO (Path Abs Dir)
forall (m :: * -> *). MonadThrow m => FilePath -> m (Path Abs Dir)
parseAbsDir)
class AnyPath path where
type AbsPath path :: Type
type RelPath path :: Type
canonicalizePath ::
(MonadIO m) =>
path ->
m (AbsPath path)
makeAbsolute ::
(MonadIO m) =>
path ->
m (AbsPath path)
makeRelative ::
(MonadThrow m) =>
Path Abs Dir ->
path ->
m (RelPath path)
makeRelativeToCurrentDir ::
(MonadIO m) =>
path ->
m (RelPath path)
instance AnyPath (Path b File) where
type AbsPath (Path b File) = Path Abs File
type RelPath (Path b File) = Path Rel File
canonicalizePath :: forall (m :: * -> *).
MonadIO m =>
Path b File -> m (AbsPath (Path b File))
canonicalizePath = (FilePath -> IO (AbsPath (Path b File)))
-> Path b File -> m (AbsPath (Path b File))
forall (m :: * -> *) a b t.
MonadIO m =>
(FilePath -> IO a) -> Path b t -> m a
liftD ((FilePath -> IO (AbsPath (Path b File)))
-> Path b File -> m (AbsPath (Path b File)))
-> (FilePath -> IO (AbsPath (Path b File)))
-> Path b File
-> m (AbsPath (Path b File))
forall a b. (a -> b) -> a -> b
$ FilePath -> IO FilePath
D.canonicalizePath (FilePath -> IO FilePath)
-> (FilePath -> IO (Path Abs File))
-> FilePath
-> IO (Path Abs File)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> FilePath -> IO (Path Abs File)
forall (m :: * -> *). MonadThrow m => FilePath -> m (Path Abs File)
parseAbsFile
makeAbsolute :: forall (m :: * -> *).
MonadIO m =>
Path b File -> m (AbsPath (Path b File))
makeAbsolute = (FilePath -> IO (AbsPath (Path b File)))
-> Path b File -> m (AbsPath (Path b File))
forall (m :: * -> *) a b t.
MonadIO m =>
(FilePath -> IO a) -> Path b t -> m a
liftD ((FilePath -> IO (AbsPath (Path b File)))
-> Path b File -> m (AbsPath (Path b File)))
-> (FilePath -> IO (AbsPath (Path b File)))
-> Path b File
-> m (AbsPath (Path b File))
forall a b. (a -> b) -> a -> b
$ FilePath -> IO FilePath
D.makeAbsolute (FilePath -> IO FilePath)
-> (FilePath -> IO (Path Abs File))
-> FilePath
-> IO (Path Abs File)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> FilePath -> IO (Path Abs File)
forall (m :: * -> *). MonadThrow m => FilePath -> m (Path Abs File)
parseAbsFile
makeRelative :: forall (m :: * -> *).
MonadThrow m =>
Path Abs Dir -> Path b File -> m (RelPath (Path b File))
makeRelative Path Abs Dir
b Path b File
p = FilePath -> m (Path Rel File)
forall (m :: * -> *). MonadThrow m => FilePath -> m (Path Rel File)
parseRelFile (FilePath -> FilePath -> FilePath
F.makeRelative (Path Abs Dir -> FilePath
forall b t. Path b t -> FilePath
toFilePath Path Abs Dir
b) (Path b File -> FilePath
forall b t. Path b t -> FilePath
toFilePath Path b File
p))
makeRelativeToCurrentDir :: forall (m :: * -> *).
MonadIO m =>
Path b File -> m (RelPath (Path b File))
makeRelativeToCurrentDir Path b File
p = IO (RelPath (Path b File)) -> m (RelPath (Path b File))
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (RelPath (Path b File)) -> m (RelPath (Path b File)))
-> IO (RelPath (Path b File)) -> m (RelPath (Path b File))
forall a b. (a -> b) -> a -> b
$ IO (Path Abs Dir)
forall (m :: * -> *). MonadIO m => m (Path Abs Dir)
getCurrentDir IO (Path Abs Dir)
-> (Path Abs Dir -> IO (Path Rel File)) -> IO (Path Rel File)
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (Path Abs Dir -> Path b File -> IO (Path Rel File))
-> Path b File -> Path Abs Dir -> IO (Path Rel File)
forall a b c. (a -> b -> c) -> b -> a -> c
flip Path Abs Dir -> Path b File -> IO (Path Rel File)
Path Abs Dir -> Path b File -> IO (RelPath (Path b File))
forall path (m :: * -> *).
(AnyPath path, MonadThrow m) =>
Path Abs Dir -> path -> m (RelPath path)
forall (m :: * -> *).
MonadThrow m =>
Path Abs Dir -> Path b File -> m (RelPath (Path b File))
makeRelative Path b File
p
instance AnyPath (Path b Dir) where
type AbsPath (Path b Dir) = Path Abs Dir
type RelPath (Path b Dir) = Path Rel Dir
canonicalizePath :: forall (m :: * -> *).
MonadIO m =>
Path b Dir -> m (AbsPath (Path b Dir))
canonicalizePath = (FilePath -> IO FilePath) -> Path b Dir -> m FilePath
forall (m :: * -> *) a b t.
MonadIO m =>
(FilePath -> IO a) -> Path b t -> m a
liftD FilePath -> IO FilePath
D.canonicalizePath (Path b Dir -> m FilePath)
-> (FilePath -> m (Path Abs Dir)) -> Path b Dir -> m (Path Abs Dir)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> IO (Path Abs Dir) -> m (Path Abs Dir)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Path Abs Dir) -> m (Path Abs Dir))
-> (FilePath -> IO (Path Abs Dir)) -> FilePath -> m (Path Abs Dir)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. FilePath -> IO (Path Abs Dir)
forall (m :: * -> *). MonadThrow m => FilePath -> m (Path Abs Dir)
parseAbsDir
makeAbsolute :: forall (m :: * -> *).
MonadIO m =>
Path b Dir -> m (AbsPath (Path b Dir))
makeAbsolute = (FilePath -> IO FilePath) -> Path b Dir -> m FilePath
forall (m :: * -> *) a b t.
MonadIO m =>
(FilePath -> IO a) -> Path b t -> m a
liftD FilePath -> IO FilePath
D.makeAbsolute (Path b Dir -> m FilePath)
-> (FilePath -> m (Path Abs Dir)) -> Path b Dir -> m (Path Abs Dir)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> IO (Path Abs Dir) -> m (Path Abs Dir)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Path Abs Dir) -> m (Path Abs Dir))
-> (FilePath -> IO (Path Abs Dir)) -> FilePath -> m (Path Abs Dir)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. FilePath -> IO (Path Abs Dir)
forall (m :: * -> *). MonadThrow m => FilePath -> m (Path Abs Dir)
parseAbsDir
makeRelative :: forall (m :: * -> *).
MonadThrow m =>
Path Abs Dir -> Path b Dir -> m (RelPath (Path b Dir))
makeRelative Path Abs Dir
b Path b Dir
p = FilePath -> m (Path Rel Dir)
forall (m :: * -> *). MonadThrow m => FilePath -> m (Path Rel Dir)
parseRelDir (FilePath -> FilePath -> FilePath
F.makeRelative (Path Abs Dir -> FilePath
forall b t. Path b t -> FilePath
toFilePath Path Abs Dir
b) (Path b Dir -> FilePath
forall b t. Path b t -> FilePath
toFilePath Path b Dir
p))
makeRelativeToCurrentDir :: forall (m :: * -> *).
MonadIO m =>
Path b Dir -> m (RelPath (Path b Dir))
makeRelativeToCurrentDir Path b Dir
p = IO (RelPath (Path b Dir)) -> m (RelPath (Path b Dir))
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (RelPath (Path b Dir)) -> m (RelPath (Path b Dir)))
-> IO (RelPath (Path b Dir)) -> m (RelPath (Path b Dir))
forall a b. (a -> b) -> a -> b
$ IO (Path Abs Dir)
forall (m :: * -> *). MonadIO m => m (Path Abs Dir)
getCurrentDir IO (Path Abs Dir)
-> (Path Abs Dir -> IO (Path Rel Dir)) -> IO (Path Rel Dir)
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (Path Abs Dir -> Path b Dir -> IO (Path Rel Dir))
-> Path b Dir -> Path Abs Dir -> IO (Path Rel Dir)
forall a b c. (a -> b -> c) -> b -> a -> c
flip Path Abs Dir -> Path b Dir -> IO (Path Rel Dir)
Path Abs Dir -> Path b Dir -> IO (RelPath (Path b Dir))
forall path (m :: * -> *).
(AnyPath path, MonadThrow m) =>
Path Abs Dir -> path -> m (RelPath path)
forall (m :: * -> *).
MonadThrow m =>
Path Abs Dir -> Path b Dir -> m (RelPath (Path b Dir))
makeRelative Path b Dir
p
instance AnyPath (SomeBase File) where
type AbsPath (SomeBase File) = Path Abs File
type RelPath (SomeBase File) = Path Rel File
canonicalizePath :: forall (m :: * -> *).
MonadIO m =>
SomeBase File -> m (AbsPath (SomeBase File))
canonicalizePath SomeBase File
s = case SomeBase File
s of
Abs Path Abs File
a -> Path Abs File -> m (AbsPath (Path Abs File))
forall path (m :: * -> *).
(AnyPath path, MonadIO m) =>
path -> m (AbsPath path)
forall (m :: * -> *).
MonadIO m =>
Path Abs File -> m (AbsPath (Path Abs File))
canonicalizePath Path Abs File
a
Rel Path Rel File
a -> Path Rel File -> m (AbsPath (Path Rel File))
forall path (m :: * -> *).
(AnyPath path, MonadIO m) =>
path -> m (AbsPath path)
forall (m :: * -> *).
MonadIO m =>
Path Rel File -> m (AbsPath (Path Rel File))
canonicalizePath Path Rel File
a
makeAbsolute :: forall (m :: * -> *).
MonadIO m =>
SomeBase File -> m (AbsPath (SomeBase File))
makeAbsolute SomeBase File
s = case SomeBase File
s of
Abs Path Abs File
a -> Path Abs File -> m (AbsPath (Path Abs File))
forall path (m :: * -> *).
(AnyPath path, MonadIO m) =>
path -> m (AbsPath path)
forall (m :: * -> *).
MonadIO m =>
Path Abs File -> m (AbsPath (Path Abs File))
makeAbsolute Path Abs File
a
Rel Path Rel File
a -> Path Rel File -> m (AbsPath (Path Rel File))
forall path (m :: * -> *).
(AnyPath path, MonadIO m) =>
path -> m (AbsPath path)
forall (m :: * -> *).
MonadIO m =>
Path Rel File -> m (AbsPath (Path Rel File))
makeAbsolute Path Rel File
a
makeRelative :: forall (m :: * -> *).
MonadThrow m =>
Path Abs Dir -> SomeBase File -> m (RelPath (SomeBase File))
makeRelative Path Abs Dir
r SomeBase File
s = case SomeBase File
s of
Abs Path Abs File
a -> Path Abs Dir -> Path Abs File -> m (RelPath (Path Abs File))
forall path (m :: * -> *).
(AnyPath path, MonadThrow m) =>
Path Abs Dir -> path -> m (RelPath path)
forall (m :: * -> *).
MonadThrow m =>
Path Abs Dir -> Path Abs File -> m (RelPath (Path Abs File))
makeRelative Path Abs Dir
r Path Abs File
a
Rel Path Rel File
a -> Path Abs Dir -> Path Rel File -> m (RelPath (Path Rel File))
forall path (m :: * -> *).
(AnyPath path, MonadThrow m) =>
Path Abs Dir -> path -> m (RelPath path)
forall (m :: * -> *).
MonadThrow m =>
Path Abs Dir -> Path Rel File -> m (RelPath (Path Rel File))
makeRelative Path Abs Dir
r Path Rel File
a
makeRelativeToCurrentDir :: forall (m :: * -> *).
MonadIO m =>
SomeBase File -> m (RelPath (SomeBase File))
makeRelativeToCurrentDir SomeBase File
s = case SomeBase File
s of
Abs Path Abs File
a -> Path Abs File -> m (RelPath (Path Abs File))
forall path (m :: * -> *).
(AnyPath path, MonadIO m) =>
path -> m (RelPath path)
forall (m :: * -> *).
MonadIO m =>
Path Abs File -> m (RelPath (Path Abs File))
makeRelativeToCurrentDir Path Abs File
a
Rel Path Rel File
a -> Path Rel File -> m (RelPath (Path Rel File))
forall path (m :: * -> *).
(AnyPath path, MonadIO m) =>
path -> m (RelPath path)
forall (m :: * -> *).
MonadIO m =>
Path Rel File -> m (RelPath (Path Rel File))
makeRelativeToCurrentDir Path Rel File
a
instance AnyPath (SomeBase Dir) where
type AbsPath (SomeBase Dir) = Path Abs Dir
type RelPath (SomeBase Dir) = Path Rel Dir
canonicalizePath :: forall (m :: * -> *).
MonadIO m =>
SomeBase Dir -> m (AbsPath (SomeBase Dir))
canonicalizePath SomeBase Dir
s = case SomeBase Dir
s of
Abs Path Abs Dir
a -> Path Abs Dir -> m (AbsPath (Path Abs Dir))
forall path (m :: * -> *).
(AnyPath path, MonadIO m) =>
path -> m (AbsPath path)
forall (m :: * -> *).
MonadIO m =>
Path Abs Dir -> m (AbsPath (Path Abs Dir))
canonicalizePath Path Abs Dir
a
Rel Path Rel Dir
a -> Path Rel Dir -> m (AbsPath (Path Rel Dir))
forall path (m :: * -> *).
(AnyPath path, MonadIO m) =>
path -> m (AbsPath path)
forall (m :: * -> *).
MonadIO m =>
Path Rel Dir -> m (AbsPath (Path Rel Dir))
canonicalizePath Path Rel Dir
a
makeAbsolute :: forall (m :: * -> *).
MonadIO m =>
SomeBase Dir -> m (AbsPath (SomeBase Dir))
makeAbsolute SomeBase Dir
s = case SomeBase Dir
s of
Abs Path Abs Dir
a -> Path Abs Dir -> m (AbsPath (Path Abs Dir))
forall path (m :: * -> *).
(AnyPath path, MonadIO m) =>
path -> m (AbsPath path)
forall (m :: * -> *).
MonadIO m =>
Path Abs Dir -> m (AbsPath (Path Abs Dir))
makeAbsolute Path Abs Dir
a
Rel Path Rel Dir
a -> Path Rel Dir -> m (AbsPath (Path Rel Dir))
forall path (m :: * -> *).
(AnyPath path, MonadIO m) =>
path -> m (AbsPath path)
forall (m :: * -> *).
MonadIO m =>
Path Rel Dir -> m (AbsPath (Path Rel Dir))
makeAbsolute Path Rel Dir
a
makeRelative :: forall (m :: * -> *).
MonadThrow m =>
Path Abs Dir -> SomeBase Dir -> m (RelPath (SomeBase Dir))
makeRelative Path Abs Dir
r SomeBase Dir
s = case SomeBase Dir
s of
Abs Path Abs Dir
a -> Path Abs Dir -> Path Abs Dir -> m (RelPath (Path Abs Dir))
forall path (m :: * -> *).
(AnyPath path, MonadThrow m) =>
Path Abs Dir -> path -> m (RelPath path)
forall (m :: * -> *).
MonadThrow m =>
Path Abs Dir -> Path Abs Dir -> m (RelPath (Path Abs Dir))
makeRelative Path Abs Dir
r Path Abs Dir
a
Rel Path Rel Dir
a -> Path Abs Dir -> Path Rel Dir -> m (RelPath (Path Rel Dir))
forall path (m :: * -> *).
(AnyPath path, MonadThrow m) =>
Path Abs Dir -> path -> m (RelPath path)
forall (m :: * -> *).
MonadThrow m =>
Path Abs Dir -> Path Rel Dir -> m (RelPath (Path Rel Dir))
makeRelative Path Abs Dir
r Path Rel Dir
a
makeRelativeToCurrentDir :: forall (m :: * -> *).
MonadIO m =>
SomeBase Dir -> m (RelPath (SomeBase Dir))
makeRelativeToCurrentDir SomeBase Dir
s = case SomeBase Dir
s of
Abs Path Abs Dir
a -> Path Abs Dir -> m (RelPath (Path Abs Dir))
forall path (m :: * -> *).
(AnyPath path, MonadIO m) =>
path -> m (RelPath path)
forall (m :: * -> *).
MonadIO m =>
Path Abs Dir -> m (RelPath (Path Abs Dir))
makeRelativeToCurrentDir Path Abs Dir
a
Rel Path Rel Dir
a -> Path Rel Dir -> m (RelPath (Path Rel Dir))
forall path (m :: * -> *).
(AnyPath path, MonadIO m) =>
path -> m (RelPath path)
forall (m :: * -> *).
MonadIO m =>
Path Rel Dir -> m (RelPath (Path Rel Dir))
makeRelativeToCurrentDir Path Rel Dir
a
resolveFile ::
(MonadIO m) =>
Path Abs Dir ->
FilePath ->
m (Path Abs File)
resolveFile :: forall (m :: * -> *).
MonadIO m =>
Path Abs Dir -> FilePath -> m (Path Abs File)
resolveFile Path Abs Dir
b FilePath
p = IO (Path Abs File) -> m (Path Abs File)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Path Abs File) -> m (Path Abs File))
-> IO (Path Abs File) -> m (Path Abs File)
forall a b. (a -> b) -> a -> b
$ FilePath -> IO FilePath
D.canonicalizePath (Path Abs Dir -> FilePath
forall b t. Path b t -> FilePath
toFilePath Path Abs Dir
b FilePath -> FilePath -> FilePath
F.</> FilePath
p) IO FilePath
-> (FilePath -> IO (Path Abs File)) -> IO (Path Abs File)
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FilePath -> IO (Path Abs File)
forall (m :: * -> *). MonadThrow m => FilePath -> m (Path Abs File)
parseAbsFile
resolveFile' ::
(MonadIO m) =>
FilePath ->
m (Path Abs File)
resolveFile' :: forall (m :: * -> *). MonadIO m => FilePath -> m (Path Abs File)
resolveFile' FilePath
p = m (Path Abs Dir)
forall (m :: * -> *). MonadIO m => m (Path Abs Dir)
getCurrentDir m (Path Abs Dir)
-> (Path Abs Dir -> m (Path Abs File)) -> m (Path Abs File)
forall a b. m a -> (a -> m b) -> m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (Path Abs Dir -> FilePath -> m (Path Abs File))
-> FilePath -> Path Abs Dir -> m (Path Abs File)
forall a b c. (a -> b -> c) -> b -> a -> c
flip Path Abs Dir -> FilePath -> m (Path Abs File)
forall (m :: * -> *).
MonadIO m =>
Path Abs Dir -> FilePath -> m (Path Abs File)
resolveFile FilePath
p
resolveDir ::
(MonadIO m) =>
Path Abs Dir ->
FilePath ->
m (Path Abs Dir)
resolveDir :: forall (m :: * -> *).
MonadIO m =>
Path Abs Dir -> FilePath -> m (Path Abs Dir)
resolveDir Path Abs Dir
b FilePath
p = IO (Path Abs Dir) -> m (Path Abs Dir)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Path Abs Dir) -> m (Path Abs Dir))
-> IO (Path Abs Dir) -> m (Path Abs Dir)
forall a b. (a -> b) -> a -> b
$ FilePath -> IO FilePath
D.canonicalizePath (Path Abs Dir -> FilePath
forall b t. Path b t -> FilePath
toFilePath Path Abs Dir
b FilePath -> FilePath -> FilePath
F.</> FilePath
p) IO FilePath -> (FilePath -> IO (Path Abs Dir)) -> IO (Path Abs Dir)
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FilePath -> IO (Path Abs Dir)
forall (m :: * -> *). MonadThrow m => FilePath -> m (Path Abs Dir)
parseAbsDir
resolveDir' ::
(MonadIO m) =>
FilePath ->
m (Path Abs Dir)
resolveDir' :: forall (m :: * -> *). MonadIO m => FilePath -> m (Path Abs Dir)
resolveDir' FilePath
p = m (Path Abs Dir)
forall (m :: * -> *). MonadIO m => m (Path Abs Dir)
getCurrentDir m (Path Abs Dir)
-> (Path Abs Dir -> m (Path Abs Dir)) -> m (Path Abs Dir)
forall a b. m a -> (a -> m b) -> m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (Path Abs Dir -> FilePath -> m (Path Abs Dir))
-> FilePath -> Path Abs Dir -> m (Path Abs Dir)
forall a b c. (a -> b -> c) -> b -> a -> c
flip Path Abs Dir -> FilePath -> m (Path Abs Dir)
forall (m :: * -> *).
MonadIO m =>
Path Abs Dir -> FilePath -> m (Path Abs Dir)
resolveDir FilePath
p
removeFile :: (MonadIO m) => Path b File -> m ()
removeFile :: forall (m :: * -> *) b. MonadIO m => Path b File -> m ()
removeFile = (FilePath -> IO ()) -> Path b File -> m ()
forall (m :: * -> *) a b t.
MonadIO m =>
(FilePath -> IO a) -> Path b t -> m a
liftD FilePath -> IO ()
D.removeFile
renameFile ::
(MonadIO m) =>
Path b0 File ->
Path b1 File ->
m ()
renameFile :: forall (m :: * -> *) b0 b1.
MonadIO m =>
Path b0 File -> Path b1 File -> m ()
renameFile = (FilePath -> FilePath -> IO ())
-> Path b0 File -> Path b1 File -> m ()
forall (m :: * -> *) a b0 t0 b1 t1.
MonadIO m =>
(FilePath -> FilePath -> IO a) -> Path b0 t0 -> Path b1 t1 -> m a
liftD2 FilePath -> FilePath -> IO ()
D.renameFile
copyFile ::
(MonadIO m) =>
Path b0 File ->
Path b1 File ->
m ()
copyFile :: forall (m :: * -> *) b0 b1.
MonadIO m =>
Path b0 File -> Path b1 File -> m ()
copyFile = (FilePath -> FilePath -> IO ())
-> Path b0 File -> Path b1 File -> m ()
forall (m :: * -> *) a b0 t0 b1 t1.
MonadIO m =>
(FilePath -> FilePath -> IO a) -> Path b0 t0 -> Path b1 t1 -> m a
liftD2 FilePath -> FilePath -> IO ()
D.copyFile
getFileSize :: (MonadIO m) => Path b File -> m Integer
getFileSize :: forall (m :: * -> *) b. MonadIO m => Path b File -> m Integer
getFileSize = (FilePath -> IO Integer) -> Path b File -> m Integer
forall (m :: * -> *) a b t.
MonadIO m =>
(FilePath -> IO a) -> Path b t -> m a
liftD FilePath -> IO Integer
D.getFileSize
findExecutable ::
(MonadIO m) =>
Path Rel File ->
m (Maybe (Path Abs File))
findExecutable :: forall (m :: * -> *).
MonadIO m =>
Path Rel File -> m (Maybe (Path Abs File))
findExecutable = (Maybe FilePath -> Maybe (Path Abs File))
-> m (Maybe FilePath) -> m (Maybe (Path Abs File))
forall a b. (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Maybe FilePath
-> (FilePath -> Maybe (Path Abs File)) -> Maybe (Path Abs File)
forall a b. Maybe a -> (a -> Maybe b) -> Maybe b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FilePath -> Maybe (Path Abs File)
forall (m :: * -> *). MonadThrow m => FilePath -> m (Path Abs File)
parseAbsFile) (m (Maybe FilePath) -> m (Maybe (Path Abs File)))
-> (Path Rel File -> m (Maybe FilePath))
-> Path Rel File
-> m (Maybe (Path Abs File))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (FilePath -> IO (Maybe FilePath))
-> Path Rel File -> m (Maybe FilePath)
forall (m :: * -> *) a b t.
MonadIO m =>
(FilePath -> IO a) -> Path b t -> m a
liftD FilePath -> IO (Maybe FilePath)
D.findExecutable
findFile ::
(MonadIO m) =>
[Path b Dir] ->
Path Rel File ->
m (Maybe (Path Abs File))
findFile :: forall (m :: * -> *) b.
MonadIO m =>
[Path b Dir] -> Path Rel File -> m (Maybe (Path Abs File))
findFile [] Path Rel File
_ = Maybe (Path Abs File) -> m (Maybe (Path Abs File))
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe (Path Abs File)
forall a. Maybe a
Nothing
findFile (Path b Dir
d : [Path b Dir]
ds) Path Rel File
file = do
Path Abs File
bfile <- (Path Abs Dir -> Path Rel File -> Path Abs File
forall b t. Path b Dir -> Path Rel t -> Path b t
</> Path Rel File
file) (Path Abs Dir -> Path Abs File)
-> m (Path Abs Dir) -> m (Path Abs File)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Path b Dir -> m (AbsPath (Path b Dir))
forall path (m :: * -> *).
(AnyPath path, MonadIO m) =>
path -> m (AbsPath path)
forall (m :: * -> *).
MonadIO m =>
Path b Dir -> m (AbsPath (Path b Dir))
makeAbsolute Path b Dir
d
Bool
exist <- Path Abs File -> m Bool
forall (m :: * -> *) b. MonadIO m => Path b File -> m Bool
doesFileExist Path Abs File
bfile
if Bool
exist
then Maybe (Path Abs File) -> m (Maybe (Path Abs File))
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Path Abs File -> Maybe (Path Abs File)
forall a. a -> Maybe a
Just Path Abs File
bfile)
else [Path b Dir] -> Path Rel File -> m (Maybe (Path Abs File))
forall (m :: * -> *) b.
MonadIO m =>
[Path b Dir] -> Path Rel File -> m (Maybe (Path Abs File))
findFile [Path b Dir]
ds Path Rel File
file
findFiles ::
(MonadIO m) =>
[Path b Dir] ->
Path Rel File ->
m [Path Abs File]
findFiles :: forall (m :: * -> *) b.
MonadIO m =>
[Path b Dir] -> Path Rel File -> m [Path Abs File]
findFiles = (Path Abs File -> m Bool)
-> [Path b Dir] -> Path Rel File -> m [Path Abs File]
forall (m :: * -> *) b.
MonadIO m =>
(Path Abs File -> m Bool)
-> [Path b Dir] -> Path Rel File -> m [Path Abs File]
findFilesWith (m Bool -> Path Abs File -> m Bool
forall a b. a -> b -> a
const (Bool -> m Bool
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
True))
findFilesWith ::
(MonadIO m) =>
(Path Abs File -> m Bool) ->
[Path b Dir] ->
Path Rel File ->
m [Path Abs File]
findFilesWith :: forall (m :: * -> *) b.
MonadIO m =>
(Path Abs File -> m Bool)
-> [Path b Dir] -> Path Rel File -> m [Path Abs File]
findFilesWith Path Abs File -> m Bool
_ [] Path Rel File
_ = [Path Abs File] -> m [Path Abs File]
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return []
findFilesWith Path Abs File -> m Bool
f (Path b Dir
d : [Path b Dir]
ds) Path Rel File
file = do
Path Abs File
bfile <- (Path Abs Dir -> Path Rel File -> Path Abs File
forall b t. Path b Dir -> Path Rel t -> Path b t
</> Path Rel File
file) (Path Abs Dir -> Path Abs File)
-> m (Path Abs Dir) -> m (Path Abs File)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Path b Dir -> m (AbsPath (Path b Dir))
forall path (m :: * -> *).
(AnyPath path, MonadIO m) =>
path -> m (AbsPath path)
forall (m :: * -> *).
MonadIO m =>
Path b Dir -> m (AbsPath (Path b Dir))
makeAbsolute Path b Dir
d
Bool
exist <- Path Abs File -> m Bool
forall (m :: * -> *) b. MonadIO m => Path b File -> m Bool
doesFileExist Path Abs File
bfile
Bool
b <- if Bool
exist then Path Abs File -> m Bool
f Path Abs File
bfile else Bool -> m Bool
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
False
if Bool
b
then (Path Abs File
bfile :) ([Path Abs File] -> [Path Abs File])
-> m [Path Abs File] -> m [Path Abs File]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Path Abs File -> m Bool)
-> [Path b Dir] -> Path Rel File -> m [Path Abs File]
forall (m :: * -> *) b.
MonadIO m =>
(Path Abs File -> m Bool)
-> [Path b Dir] -> Path Rel File -> m [Path Abs File]
findFilesWith Path Abs File -> m Bool
f [Path b Dir]
ds Path Rel File
file
else (Path Abs File -> m Bool)
-> [Path b Dir] -> Path Rel File -> m [Path Abs File]
forall (m :: * -> *) b.
MonadIO m =>
(Path Abs File -> m Bool)
-> [Path b Dir] -> Path Rel File -> m [Path Abs File]
findFilesWith Path Abs File -> m Bool
f [Path b Dir]
ds Path Rel File
file
createFileLink ::
(MonadIO m) =>
Path b0 File ->
Path b1 File ->
m ()
createFileLink :: forall (m :: * -> *) b0 b1.
MonadIO m =>
Path b0 File -> Path b1 File -> m ()
createFileLink = (FilePath -> FilePath -> IO ())
-> Path b0 File -> Path b1 File -> m ()
forall (m :: * -> *) a b0 t0 b1 t1.
MonadIO m =>
(FilePath -> FilePath -> IO a) -> Path b0 t0 -> Path b1 t1 -> m a
liftD2 FilePath -> FilePath -> IO ()
D.createFileLink
createDirLink ::
(MonadIO m) =>
Path b0 Dir ->
Path b1 Dir ->
m ()
createDirLink :: forall (m :: * -> *) b0 b1.
MonadIO m =>
Path b0 Dir -> Path b1 Dir -> m ()
createDirLink Path b0 Dir
target' Path b1 Dir
dest' = do
let target :: FilePath
target = Path b0 Dir -> FilePath
forall b t. Path b t -> FilePath
toFilePath Path b0 Dir
target'
dest :: FilePath
dest = Path b1 Dir -> FilePath
forall b t. Path b t -> FilePath
toFilePath' Path b1 Dir
dest'
IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FilePath -> FilePath -> IO ()
D.createDirectoryLink FilePath
target FilePath
dest
removeDirLink ::
(MonadIO m) =>
Path b Dir ->
m ()
removeDirLink :: forall (m :: * -> *) b. MonadIO m => Path b Dir -> m ()
removeDirLink = (FilePath -> IO ()) -> Path b Dir -> m ()
forall (m :: * -> *) a b t.
MonadIO m =>
(FilePath -> IO a) -> Path b t -> m a
liftD FilePath -> IO ()
D.removeDirectoryLink
getSymlinkTarget ::
(MonadIO m) =>
Path b t ->
m FilePath
getSymlinkTarget :: forall (m :: * -> *) b t. MonadIO m => Path b t -> m FilePath
getSymlinkTarget = (FilePath -> IO FilePath) -> Path b t -> m FilePath
forall (m :: * -> *) a b t.
MonadIO m =>
(FilePath -> IO a) -> Path b t -> m a
liftD FilePath -> IO FilePath
D.getSymbolicLinkTarget
isSymlink :: (MonadIO m) => Path b t -> m Bool
isSymlink :: forall (m :: * -> *) b t. MonadIO m => Path b t -> m Bool
isSymlink = (FilePath -> IO Bool) -> Path b t -> m Bool
forall (m :: * -> *) a b t.
MonadIO m =>
(FilePath -> IO a) -> Path b t -> m a
liftD FilePath -> IO Bool
D.pathIsSymbolicLink
withTempFile ::
(MonadIO m, MonadMask m) =>
Path b Dir ->
String ->
(Path Abs File -> Handle -> m a) ->
m a
withTempFile :: forall (m :: * -> *) b a.
(MonadIO m, MonadMask m) =>
Path b Dir -> FilePath -> (Path Abs File -> Handle -> m a) -> m a
withTempFile Path b Dir
path FilePath
t Path Abs File -> Handle -> m a
action = do
Path Abs Dir
apath <- Path b Dir -> m (AbsPath (Path b Dir))
forall path (m :: * -> *).
(AnyPath path, MonadIO m) =>
path -> m (AbsPath path)
forall (m :: * -> *).
MonadIO m =>
Path b Dir -> m (AbsPath (Path b Dir))
makeAbsolute Path b Dir
path
FilePath -> FilePath -> (FilePath -> Handle -> m a) -> m a
forall (m :: * -> *) a.
(MonadIO m, MonadMask m) =>
FilePath -> FilePath -> (FilePath -> Handle -> m a) -> m a
T.withTempFile (Path Abs Dir -> FilePath
forall b t. Path b t -> FilePath
toFilePath Path Abs Dir
apath) FilePath
t ((FilePath -> Handle -> m a) -> m a)
-> (FilePath -> Handle -> m a) -> m a
forall a b. (a -> b) -> a -> b
$ \FilePath
file Handle
h ->
FilePath -> m (Path Abs File)
forall (m :: * -> *). MonadThrow m => FilePath -> m (Path Abs File)
parseAbsFile FilePath
file m (Path Abs File) -> (Path Abs File -> m a) -> m a
forall a b. m a -> (a -> m b) -> m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (Path Abs File -> Handle -> m a) -> Handle -> Path Abs File -> m a
forall a b c. (a -> b -> c) -> b -> a -> c
flip Path Abs File -> Handle -> m a
action Handle
h
withTempDir ::
(MonadIO m, MonadMask m) =>
Path b Dir ->
String ->
(Path Abs Dir -> m a) ->
m a
withTempDir :: forall (m :: * -> *) b a.
(MonadIO m, MonadMask m) =>
Path b Dir -> FilePath -> (Path Abs Dir -> m a) -> m a
withTempDir Path b Dir
path FilePath
t Path Abs Dir -> m a
action = do
Path Abs Dir
apath <- Path b Dir -> m (AbsPath (Path b Dir))
forall path (m :: * -> *).
(AnyPath path, MonadIO m) =>
path -> m (AbsPath path)
forall (m :: * -> *).
MonadIO m =>
Path b Dir -> m (AbsPath (Path b Dir))
makeAbsolute Path b Dir
path
FilePath -> FilePath -> (FilePath -> m a) -> m a
forall (m :: * -> *) a.
(MonadMask m, MonadIO m) =>
FilePath -> FilePath -> (FilePath -> m a) -> m a
T.withTempDirectory (Path Abs Dir -> FilePath
forall b t. Path b t -> FilePath
toFilePath Path Abs Dir
apath) FilePath
t (FilePath -> m (Path Abs Dir)
forall (m :: * -> *). MonadThrow m => FilePath -> m (Path Abs Dir)
parseAbsDir (FilePath -> m (Path Abs Dir))
-> (Path Abs Dir -> m a) -> FilePath -> m a
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Path Abs Dir -> m a
action)
withSystemTempFile ::
(MonadIO m, MonadMask m) =>
String ->
(Path Abs File -> Handle -> m a) ->
m a
withSystemTempFile :: forall (m :: * -> *) a.
(MonadIO m, MonadMask m) =>
FilePath -> (Path Abs File -> Handle -> m a) -> m a
withSystemTempFile FilePath
t Path Abs File -> Handle -> m a
action =
m (Path Abs Dir)
forall (m :: * -> *). MonadIO m => m (Path Abs Dir)
getTempDir m (Path Abs Dir) -> (Path Abs Dir -> m a) -> m a
forall a b. m a -> (a -> m b) -> m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Path Abs Dir
path ->
Path Abs Dir -> FilePath -> (Path Abs File -> Handle -> m a) -> m a
forall (m :: * -> *) b a.
(MonadIO m, MonadMask m) =>
Path b Dir -> FilePath -> (Path Abs File -> Handle -> m a) -> m a
withTempFile Path Abs Dir
path FilePath
t Path Abs File -> Handle -> m a
action
withSystemTempDir ::
(MonadIO m, MonadMask m) =>
String ->
(Path Abs Dir -> m a) ->
m a
withSystemTempDir :: forall (m :: * -> *) a.
(MonadIO m, MonadMask m) =>
FilePath -> (Path Abs Dir -> m a) -> m a
withSystemTempDir FilePath
t Path Abs Dir -> m a
action =
m (Path Abs Dir)
forall (m :: * -> *). MonadIO m => m (Path Abs Dir)
getTempDir m (Path Abs Dir) -> (Path Abs Dir -> m a) -> m a
forall a b. m a -> (a -> m b) -> m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Path Abs Dir
path ->
Path Abs Dir -> FilePath -> (Path Abs Dir -> m a) -> m a
forall (m :: * -> *) b a.
(MonadIO m, MonadMask m) =>
Path b Dir -> FilePath -> (Path Abs Dir -> m a) -> m a
withTempDir Path Abs Dir
path FilePath
t Path Abs Dir -> m a
action
openTempFile ::
(MonadIO m) =>
Path b Dir ->
String ->
m (Path Abs File, Handle)
openTempFile :: forall (m :: * -> *) b.
MonadIO m =>
Path b Dir -> FilePath -> m (Path Abs File, Handle)
openTempFile Path b Dir
path FilePath
t = IO (Path Abs File, Handle) -> m (Path Abs File, Handle)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Path Abs File, Handle) -> m (Path Abs File, Handle))
-> IO (Path Abs File, Handle) -> m (Path Abs File, Handle)
forall a b. (a -> b) -> a -> b
$ do
Path Abs Dir
apath <- Path b Dir -> IO (AbsPath (Path b Dir))
forall path (m :: * -> *).
(AnyPath path, MonadIO m) =>
path -> m (AbsPath path)
forall (m :: * -> *).
MonadIO m =>
Path b Dir -> m (AbsPath (Path b Dir))
makeAbsolute Path b Dir
path
(FilePath
tfile, Handle
h) <- (FilePath -> FilePath -> IO (FilePath, Handle))
-> Path Abs Dir -> FilePath -> IO (FilePath, Handle)
forall (m :: * -> *) v a b t.
MonadIO m =>
(FilePath -> v -> IO a) -> Path b t -> v -> m a
liftD2' FilePath -> FilePath -> IO (FilePath, Handle)
T.openTempFile Path Abs Dir
apath FilePath
t
(,Handle
h) (Path Abs File -> (Path Abs File, Handle))
-> IO (Path Abs File) -> IO (Path Abs File, Handle)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> FilePath -> IO (Path Abs File)
forall (m :: * -> *). MonadThrow m => FilePath -> m (Path Abs File)
parseAbsFile FilePath
tfile
openBinaryTempFile ::
(MonadIO m) =>
Path b Dir ->
String ->
m (Path Abs File, Handle)
openBinaryTempFile :: forall (m :: * -> *) b.
MonadIO m =>
Path b Dir -> FilePath -> m (Path Abs File, Handle)
openBinaryTempFile Path b Dir
path FilePath
t = IO (Path Abs File, Handle) -> m (Path Abs File, Handle)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Path Abs File, Handle) -> m (Path Abs File, Handle))
-> IO (Path Abs File, Handle) -> m (Path Abs File, Handle)
forall a b. (a -> b) -> a -> b
$ do
Path Abs Dir
apath <- Path b Dir -> IO (AbsPath (Path b Dir))
forall path (m :: * -> *).
(AnyPath path, MonadIO m) =>
path -> m (AbsPath path)
forall (m :: * -> *).
MonadIO m =>
Path b Dir -> m (AbsPath (Path b Dir))
makeAbsolute Path b Dir
path
(FilePath
tfile, Handle
h) <- (FilePath -> FilePath -> IO (FilePath, Handle))
-> Path Abs Dir -> FilePath -> IO (FilePath, Handle)
forall (m :: * -> *) v a b t.
MonadIO m =>
(FilePath -> v -> IO a) -> Path b t -> v -> m a
liftD2' FilePath -> FilePath -> IO (FilePath, Handle)
T.openBinaryTempFile Path Abs Dir
apath FilePath
t
(,Handle
h) (Path Abs File -> (Path Abs File, Handle))
-> IO (Path Abs File) -> IO (Path Abs File, Handle)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> FilePath -> IO (Path Abs File)
forall (m :: * -> *). MonadThrow m => FilePath -> m (Path Abs File)
parseAbsFile FilePath
tfile
createTempDir ::
(MonadIO m) =>
Path b Dir ->
String ->
m (Path Abs Dir)
createTempDir :: forall (m :: * -> *) b.
MonadIO m =>
Path b Dir -> FilePath -> m (Path Abs Dir)
createTempDir Path b Dir
path FilePath
t =
IO (Path Abs Dir) -> m (Path Abs Dir)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Path Abs Dir) -> m (Path Abs Dir))
-> IO (Path Abs Dir) -> m (Path Abs Dir)
forall a b. (a -> b) -> a -> b
$
Path b Dir -> IO (AbsPath (Path b Dir))
forall path (m :: * -> *).
(AnyPath path, MonadIO m) =>
path -> m (AbsPath path)
forall (m :: * -> *).
MonadIO m =>
Path b Dir -> m (AbsPath (Path b Dir))
makeAbsolute Path b Dir
path IO (Path Abs Dir)
-> (Path Abs Dir -> IO (Path Abs Dir)) -> IO (Path Abs Dir)
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Path Abs Dir
apath ->
(FilePath -> FilePath -> IO FilePath)
-> Path Abs Dir -> FilePath -> IO FilePath
forall (m :: * -> *) v a b t.
MonadIO m =>
(FilePath -> v -> IO a) -> Path b t -> v -> m a
liftD2' FilePath -> FilePath -> IO FilePath
T.createTempDirectory Path Abs Dir
apath FilePath
t IO FilePath -> (FilePath -> IO (Path Abs Dir)) -> IO (Path Abs Dir)
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FilePath -> IO (Path Abs Dir)
forall (m :: * -> *). MonadThrow m => FilePath -> m (Path Abs Dir)
parseAbsDir
doesPathExist :: (MonadIO m) => Path b t -> m Bool
doesPathExist :: forall (m :: * -> *) b t. MonadIO m => Path b t -> m Bool
doesPathExist = (FilePath -> IO Bool) -> Path b t -> m Bool
forall (m :: * -> *) a b t.
MonadIO m =>
(FilePath -> IO a) -> Path b t -> m a
liftD FilePath -> IO Bool
D.doesPathExist
doesFileExist :: (MonadIO m) => Path b File -> m Bool
doesFileExist :: forall (m :: * -> *) b. MonadIO m => Path b File -> m Bool
doesFileExist = (FilePath -> IO Bool) -> Path b File -> m Bool
forall (m :: * -> *) a b t.
MonadIO m =>
(FilePath -> IO a) -> Path b t -> m a
liftD FilePath -> IO Bool
D.doesFileExist
doesDirExist :: (MonadIO m) => Path b Dir -> m Bool
doesDirExist :: forall (m :: * -> *) b. MonadIO m => Path b Dir -> m Bool
doesDirExist = (FilePath -> IO Bool) -> Path b Dir -> m Bool
forall (m :: * -> *) a b t.
MonadIO m =>
(FilePath -> IO a) -> Path b t -> m a
liftD FilePath -> IO Bool
D.doesDirectoryExist
isLocationOccupied :: (MonadIO m) => Path b t -> m Bool
isLocationOccupied :: forall (m :: * -> *) b t. MonadIO m => Path b t -> m Bool
isLocationOccupied Path b t
path = do
let fp :: FilePath
fp = Path b t -> FilePath
forall b t. Path b t -> FilePath
toFilePath Path b t
path
Bool
file <- IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (FilePath -> IO Bool
D.doesFileExist FilePath
fp)
Bool
dir <- IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (FilePath -> IO Bool
D.doesDirectoryExist FilePath
fp)
Bool -> m Bool
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
file Bool -> Bool -> Bool
|| Bool
dir)
forgivingAbsence :: (MonadIO m, MonadCatch m) => m a -> m (Maybe a)
forgivingAbsence :: forall (m :: * -> *) a.
(MonadIO m, MonadCatch m) =>
m a -> m (Maybe a)
forgivingAbsence m a
f =
(IOError -> Bool)
-> m (Maybe a) -> (IOError -> m (Maybe a)) -> m (Maybe a)
forall (m :: * -> *) e a.
(HasCallStack, MonadCatch m, Exception e) =>
(e -> Bool) -> m a -> (e -> m a) -> m a
catchIf
IOError -> Bool
isDoesNotExistError
(a -> Maybe a
forall a. a -> Maybe a
Just (a -> Maybe a) -> m a -> m (Maybe a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m a
f)
(m (Maybe a) -> IOError -> m (Maybe a)
forall a b. a -> b -> a
const (m (Maybe a) -> IOError -> m (Maybe a))
-> m (Maybe a) -> IOError -> m (Maybe a)
forall a b. (a -> b) -> a -> b
$ Maybe a -> m (Maybe a)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe a
forall a. Maybe a
Nothing)
ignoringAbsence :: (MonadIO m, MonadCatch m) => m a -> m ()
ignoringAbsence :: forall (m :: * -> *) a. (MonadIO m, MonadCatch m) => m a -> m ()
ignoringAbsence = m (Maybe a) -> m ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (m (Maybe a) -> m ()) -> (m a -> m (Maybe a)) -> m a -> m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. m a -> m (Maybe a)
forall (m :: * -> *) a.
(MonadIO m, MonadCatch m) =>
m a -> m (Maybe a)
forgivingAbsence
getPermissions :: (MonadIO m) => Path b t -> m D.Permissions
getPermissions :: forall (m :: * -> *) b t. MonadIO m => Path b t -> m Permissions
getPermissions = (FilePath -> IO Permissions) -> Path b t -> m Permissions
forall (m :: * -> *) a b t.
MonadIO m =>
(FilePath -> IO a) -> Path b t -> m a
liftD FilePath -> IO Permissions
D.getPermissions
setPermissions :: (MonadIO m) => Path b t -> D.Permissions -> m ()
setPermissions :: forall (m :: * -> *) b t.
MonadIO m =>
Path b t -> Permissions -> m ()
setPermissions = (FilePath -> Permissions -> IO ())
-> Path b t -> Permissions -> m ()
forall (m :: * -> *) v a b t.
MonadIO m =>
(FilePath -> v -> IO a) -> Path b t -> v -> m a
liftD2' FilePath -> Permissions -> IO ()
D.setPermissions
copyPermissions ::
(MonadIO m) =>
Path b0 t0 ->
Path b1 t1 ->
m ()
copyPermissions :: forall (m :: * -> *) b0 t0 b1 t1.
MonadIO m =>
Path b0 t0 -> Path b1 t1 -> m ()
copyPermissions = (FilePath -> FilePath -> IO ()) -> Path b0 t0 -> Path b1 t1 -> m ()
forall (m :: * -> *) a b0 t0 b1 t1.
MonadIO m =>
(FilePath -> FilePath -> IO a) -> Path b0 t0 -> Path b1 t1 -> m a
liftD2 FilePath -> FilePath -> IO ()
D.copyPermissions
getAccessTime :: (MonadIO m) => Path b t -> m UTCTime
getAccessTime :: forall (m :: * -> *) b t. MonadIO m => Path b t -> m UTCTime
getAccessTime = (FilePath -> IO UTCTime) -> Path b t -> m UTCTime
forall (m :: * -> *) a b t.
MonadIO m =>
(FilePath -> IO a) -> Path b t -> m a
liftD FilePath -> IO UTCTime
D.getAccessTime
setAccessTime :: (MonadIO m) => Path b t -> UTCTime -> m ()
setAccessTime :: forall (m :: * -> *) b t. MonadIO m => Path b t -> UTCTime -> m ()
setAccessTime = (FilePath -> UTCTime -> IO ()) -> Path b t -> UTCTime -> m ()
forall (m :: * -> *) v a b t.
MonadIO m =>
(FilePath -> v -> IO a) -> Path b t -> v -> m a
liftD2' FilePath -> UTCTime -> IO ()
D.setAccessTime
setModificationTime :: (MonadIO m) => Path b t -> UTCTime -> m ()
setModificationTime :: forall (m :: * -> *) b t. MonadIO m => Path b t -> UTCTime -> m ()
setModificationTime = (FilePath -> UTCTime -> IO ()) -> Path b t -> UTCTime -> m ()
forall (m :: * -> *) v a b t.
MonadIO m =>
(FilePath -> v -> IO a) -> Path b t -> v -> m a
liftD2' FilePath -> UTCTime -> IO ()
D.setModificationTime
getModificationTime :: (MonadIO m) => Path b t -> m UTCTime
getModificationTime :: forall (m :: * -> *) b t. MonadIO m => Path b t -> m UTCTime
getModificationTime = (FilePath -> IO UTCTime) -> Path b t -> m UTCTime
forall (m :: * -> *) a b t.
MonadIO m =>
(FilePath -> IO a) -> Path b t -> m a
liftD FilePath -> IO UTCTime
D.getModificationTime
liftD ::
(MonadIO m) =>
(FilePath -> IO a) ->
Path b t ->
m a
liftD :: forall (m :: * -> *) a b t.
MonadIO m =>
(FilePath -> IO a) -> Path b t -> m a
liftD FilePath -> IO a
m = IO a -> m a
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO a -> m a) -> (Path b t -> IO a) -> Path b t -> m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. FilePath -> IO a
m (FilePath -> IO a) -> (Path b t -> FilePath) -> Path b t -> IO a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Path b t -> FilePath
forall b t. Path b t -> FilePath
toFilePath'
{-# INLINE liftD #-}
liftD2 ::
(MonadIO m) =>
(FilePath -> FilePath -> IO a) ->
Path b0 t0 ->
Path b1 t1 ->
m a
liftD2 :: forall (m :: * -> *) a b0 t0 b1 t1.
MonadIO m =>
(FilePath -> FilePath -> IO a) -> Path b0 t0 -> Path b1 t1 -> m a
liftD2 FilePath -> FilePath -> IO a
m Path b0 t0
a Path b1 t1
b = IO a -> m a
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO a -> m a) -> IO a -> m a
forall a b. (a -> b) -> a -> b
$ FilePath -> FilePath -> IO a
m (Path b0 t0 -> FilePath
forall b t. Path b t -> FilePath
toFilePath' Path b0 t0
a) (Path b1 t1 -> FilePath
forall b t. Path b t -> FilePath
toFilePath' Path b1 t1
b)
{-# INLINE liftD2 #-}
liftD2' ::
(MonadIO m) =>
(FilePath -> v -> IO a) ->
Path b t ->
v ->
m a
liftD2' :: forall (m :: * -> *) v a b t.
MonadIO m =>
(FilePath -> v -> IO a) -> Path b t -> v -> m a
liftD2' FilePath -> v -> IO a
m Path b t
a v
v = IO a -> m a
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO a -> m a) -> IO a -> m a
forall a b. (a -> b) -> a -> b
$ FilePath -> v -> IO a
m (Path b t -> FilePath
forall b t. Path b t -> FilePath
toFilePath' Path b t
a) v
v
{-# INLINE liftD2' #-}
toFilePath' :: Path b t -> FilePath
toFilePath' :: forall b t. Path b t -> FilePath
toFilePath' = FilePath -> FilePath
F.dropTrailingPathSeparator (FilePath -> FilePath)
-> (Path b t -> FilePath) -> Path b t -> FilePath
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Path b t -> FilePath
forall b t. Path b t -> FilePath
toFilePath
ignoringIOErrors :: IO () -> IO ()
ignoringIOErrors :: IO () -> IO ()
ignoringIOErrors IO ()
ioe = IO ()
ioe IO () -> (IOError -> IO ()) -> IO ()
forall e a.
(HasCallStack, Exception e) =>
IO a -> (e -> IO a) -> IO a
forall (m :: * -> *) e a.
(MonadCatch m, HasCallStack, Exception e) =>
m a -> (e -> m a) -> m a
`catch` IOError -> IO ()
forall (m :: * -> *). Monad m => IOError -> m ()
handler
where
handler :: (Monad m) => IOError -> m ()
handler :: forall (m :: * -> *). Monad m => IOError -> m ()
handler = m () -> IOError -> m ()
forall a b. a -> b -> a
const (() -> m ()
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return ())