---------------------------------------------------------------------
-- Module      :  FileIO.Strings
--
----------------------------------------------------------------------
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE UndecidableInstances #-}
{-# LANGUAGE TypeFamilies #-}
{-# OPTIONS_GHC -fno-warn-missing-methods #-}

module Uniform.FileStrings
  ( module Uniform.Filenames,
    module Uniform.FileIOalgebra,
    SIO.IOMode (..),
    closeFile2,
    listDir',
    TIO.hGetLine,
    TIO.hPutStr,
  )
where

import Control.Arrow (first, second)
import Control.DeepSeq (force, ($!!))
import Control.Exception (SomeException, catch)
import Control.Monad (filterM, when)
import Control.Monad.Catch as Catch
  ( Exception,
    MonadThrow,
    SomeException,
  )
import Control.Monad.IO.Class (MonadIO (..))
import qualified Data.ByteString as BS (readFile, writeFile)
import qualified Data.ByteString.Lazy as L
import Data.Digest.Pure.MD5 (md5)
import Data.Either (isLeft)
import Data.List (isPrefixOf)
import Data.Maybe (catMaybes)
import qualified Data.Text.IO as T (appendFile, readFile, writeFile)
import qualified Data.Text.IO as TIO (hGetLine, hPutStr)
import qualified Path
import qualified Path.IO as PathIO
import qualified System.Directory as D
import qualified System.FilePath as OS
import qualified System.IO as SIO
import System.Posix (FileMode)
import qualified System.Posix as Posix
import Uniform.FileIOalgebra
import Uniform.FileStatus
import Uniform.Filenames
import Uniform.Filenames as FN (toFilePath)
import Uniform.Strings -- (Text)
import Uniform.Error


closeFile2 :: SIO.Handle -> ErrIO ()
-- close a handle, does not need a filepath
closeFile2 :: Handle -> ErrIO ()
closeFile2 Handle
handle = IO () -> ErrIO ()
forall (m :: * -> *) a.
(MonadError m, MonadIO m, ErrorType m ~ Text) =>
IO a -> m a
callIO (IO () -> ErrIO ()) -> IO () -> ErrIO ()
forall a b. (a -> b) -> a -> b
$ Handle -> IO ()
SIO.hClose Handle
handle

instance FileHandles String where
  write2handle :: Handle -> String -> ErrIO ()
write2handle Handle
h String
c = IO () -> ErrIO ()
forall (m :: * -> *) a.
(MonadError m, MonadIO m, ErrorType m ~ Text) =>
IO a -> m a
callIO (IO () -> ErrIO ()) -> IO () -> ErrIO ()
forall a b. (a -> b) -> a -> b
$ Handle -> String -> IO ()
SIO.hPutStr Handle
h String
c
  readLine4handle :: Handle -> ErrIO String
readLine4handle Handle
h = IO String -> ErrIO String
forall (m :: * -> *) a.
(MonadError m, MonadIO m, ErrorType m ~ Text) =>
IO a -> m a
callIO (IO String -> ErrIO String) -> IO String -> ErrIO String
forall a b. (a -> b) -> a -> b
$ Handle -> IO String
SIO.hGetLine Handle
h

instance FileHandles L.ByteString where
  write2handle :: Handle -> ByteString -> ErrIO ()
write2handle Handle
h ByteString
c = IO () -> ErrIO ()
forall (m :: * -> *) a.
(MonadError m, MonadIO m, ErrorType m ~ Text) =>
IO a -> m a
callIO (IO () -> ErrIO ()) -> IO () -> ErrIO ()
forall a b. (a -> b) -> a -> b
$ Handle -> ByteString -> IO ()
L.hPutStr Handle
h ByteString
c
  readLine4handle :: Handle -> ErrIO ByteString
readLine4handle Handle
h = String -> ErrIO ByteString
forall a. HasCallStack => String -> a
error String
"readLine4handle not implemented for lazy bytestring in FileStrings"

instance FileHandles Text where
  write2handle :: Handle -> Text -> ErrIO ()
write2handle Handle
h Text
c = IO () -> ErrIO ()
forall (m :: * -> *) a.
(MonadError m, MonadIO m, ErrorType m ~ Text) =>
IO a -> m a
callIO (IO () -> ErrIO ()) -> IO () -> ErrIO ()
forall a b. (a -> b) -> a -> b
$ Handle -> Text -> IO ()
TIO.hPutStr Handle
h Text
c
  readLine4handle :: Handle -> ErrIO Text
readLine4handle Handle
h = IO Text -> ErrIO Text
forall (m :: * -> *) a.
(MonadError m, MonadIO m, ErrorType m ~ Text) =>
IO a -> m a
callIO (IO Text -> ErrIO Text) -> IO Text -> ErrIO Text
forall a b. (a -> b) -> a -> b
$ Handle -> IO Text
TIO.hGetLine Handle
h

instance FileHandles [Text] where
  write2handle :: Handle -> [Text] -> ErrIO ()
write2handle Handle
h [Text]
c = IO () -> ErrIO ()
forall (m :: * -> *) a.
(MonadError m, MonadIO m, ErrorType m ~ Text) =>
IO a -> m a
callIO (IO () -> ErrIO ()) -> IO () -> ErrIO ()
forall a b. (a -> b) -> a -> b
$ Handle -> Text -> IO ()
TIO.hPutStr Handle
h ([Text] -> Text
forall a. CharChains a => [a] -> a
unlines' [Text]
c)
  readLine4handle :: Handle -> ErrIO [Text]
readLine4handle Handle
h = do
    Text
res <- IO Text -> ErrIO Text
forall (m :: * -> *) a.
(MonadError m, MonadIO m, ErrorType m ~ Text) =>
IO a -> m a
callIO (IO Text -> ErrIO Text) -> IO Text -> ErrIO Text
forall a b. (a -> b) -> a -> b
$ Handle -> IO Text
TIO.hGetLine Handle
h
    [Text] -> ErrIO [Text]
forall (m :: * -> *) a. Monad m => a -> m a
return ([Text] -> ErrIO [Text])
-> (Text -> [Text]) -> Text -> ErrIO [Text]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> [Text]
forall a. CharChains a => a -> [a]
lines' (Text -> ErrIO [Text]) -> Text -> ErrIO [Text]
forall a b. (a -> b) -> a -> b
$ Text
res

listDir' ::
  (MonadIO m, MonadThrow m) =>
  -- | Directory to list
  Path b Dir ->
  -- | Sub-directories and files
  m ([Path Abs Dir], [Path Abs File])
listDir' :: Path b Dir -> m ([Path Abs Dir], [Path Abs File])
listDir' Path b Dir
p = do
  ([Path Abs Dir], [Path Abs File])
abList :: ([Path.Path Abs Dir], [Path.Path Abs File]) <-
    Path b Dir -> m ([Path Abs Dir], [Path Abs File])
forall (m :: * -> *) b.
MonadIO m =>
Path b Dir -> m ([Path Abs Dir], [Path Abs File])
PathIO.listDir (Path b Dir -> m ([Path Abs Dir], [Path Abs File]))
-> (Path b Dir -> Path b Dir)
-> Path b Dir
-> m ([Path Abs Dir], [Path Abs File])
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Path b Dir -> Path b Dir
forall a. a -> a
unPath (Path b Dir -> m ([Path Abs Dir], [Path Abs File]))
-> Path b Dir -> m ([Path Abs Dir], [Path Abs File])
forall a b. (a -> b) -> a -> b
$ Path b Dir
p
  let abPathList :: ([Path Abs Dir], [Path Abs File])
abPathList = ([Path Abs Dir], [Path Abs File])
abList
  ([Path Abs Dir], [Path Abs File])
-> m ([Path Abs Dir], [Path Abs File])
forall (m :: * -> *) a. Monad m => a -> m a
return ([Path Abs Dir], [Path Abs File])
abPathList

instance FileSystemOps FilePath where
  checkSymbolicLink :: String -> ErrIO Bool
checkSymbolicLink String
fp = IO Bool -> ErrIO Bool
forall (m :: * -> *) a.
(MonadError m, MonadIO m, ErrorType m ~ Text) =>
IO a -> m a
callIO (IO Bool -> ErrIO Bool) -> IO Bool -> ErrIO Bool
forall a b. (a -> b) -> a -> b
$ String -> IO Bool
D.pathIsSymbolicLink String
fp
  getPermissions' :: String -> ErrIO Permissions
getPermissions' = IO Permissions -> ErrIO Permissions
forall (m :: * -> *) a.
(MonadError m, MonadIO m, ErrorType m ~ Text) =>
IO a -> m a
callIO (IO Permissions -> ErrIO Permissions)
-> (String -> IO Permissions) -> String -> ErrIO Permissions
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> IO Permissions
D.getPermissions

instance DirOps FilePath where
  doesDirExist' :: String -> ErrIO Bool
doesDirExist' = IO Bool -> ErrIO Bool
forall (m :: * -> *) a.
(MonadError m, MonadIO m, ErrorType m ~ Text) =>
IO a -> m a
callIO (IO Bool -> ErrIO Bool)
-> (String -> IO Bool) -> String -> ErrIO Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> IO Bool
D.doesDirectoryExist
  createDirIfMissing' :: String -> ErrIO ()
createDirIfMissing' = IO () -> ErrIO ()
forall (m :: * -> *) a.
(MonadError m, MonadIO m, ErrorType m ~ Text) =>
IO a -> m a
callIO (IO () -> ErrIO ()) -> (String -> IO ()) -> String -> ErrIO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> String -> IO ()
D.createDirectoryIfMissing Bool
True

  createDir' :: String -> ErrIO ()
createDir' = IO () -> ErrIO ()
forall (m :: * -> *) a.
(MonadError m, MonadIO m, ErrorType m ~ Text) =>
IO a -> m a
callIO (IO () -> ErrIO ()) -> (String -> IO ()) -> String -> ErrIO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> IO ()
D.createDirectory
  renameDir' :: String -> String -> ErrIO ()
renameDir' String
old String
new = do
    [Text] -> ErrIO ()
forall (m :: * -> *). MonadIO m => [Text] -> m ()
putIOwords [Text
"renamed start"]
    Bool
testSource <- String -> ErrIO Bool
forall fp. DirOps fp => fp -> ErrIO Bool
doesDirExist' String
old
    Bool
testTarget <- String -> ErrIO Bool
forall fp. DirOps fp => fp -> ErrIO Bool
doesDirExist' String
new
    if Bool
testTarget
      then
        [Text] -> ErrIO ()
forall a. [Text] -> ErrIO a
throwErrorT
          [String -> Text
forall a. Show a => a -> Text
showT String
new]
      else
        if Bool -> Bool
not Bool
testSource
          then
            [Text] -> ErrIO ()
forall a. [Text] -> ErrIO a
throwErrorT
              [String -> Text
forall a. Show a => a -> Text
showT String
old]
          else do
            IO () -> ErrIO ()
forall (m :: * -> *) a.
(MonadError m, MonadIO m, ErrorType m ~ Text) =>
IO a -> m a
callIO (IO () -> ErrIO ()) -> IO () -> ErrIO ()
forall a b. (a -> b) -> a -> b
$ String -> IO ()
putStrLn String
"renamed"
            ()
r <- IO () -> ErrIO ()
forall (m :: * -> *) a.
(MonadError m, MonadIO m, ErrorType m ~ Text) =>
IO a -> m a
callIO (IO () -> ErrIO ()) -> IO () -> ErrIO ()
forall a b. (a -> b) -> a -> b
$ String -> String -> IO ()
D.renameDirectory String
old String
new
            () -> ErrIO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

  getDirectoryDirs' :: String -> ErrIO [String]
getDirectoryDirs' String
dir = (String -> ErrIO Bool) -> [String] -> ErrIO [String]
forall (m :: * -> *) a.
Applicative m =>
(a -> m Bool) -> [a] -> m [a]
filterM String -> ErrIO Bool
f ([String] -> ErrIO [String]) -> ErrIO [String] -> ErrIO [String]
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< String -> ErrIO [String]
forall fp. FileOps fp => fp -> ErrIO [fp]
getDirCont String
dir
    where
      f :: String -> ErrIO Bool
f = String -> ErrIO Bool
forall fp. DirOps fp => fp -> ErrIO Bool
doesDirExist'
  getDirectoryDirsNonHidden' :: String -> ErrIO [String]
getDirectoryDirsNonHidden' String
dir = (String -> ErrIO Bool) -> [String] -> ErrIO [String]
forall (m :: * -> *) a.
Applicative m =>
(a -> m Bool) -> [a] -> m [a]
filterM String -> ErrIO Bool
f ([String] -> ErrIO [String]) -> ErrIO [String] -> ErrIO [String]
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< String -> ErrIO [String]
forall fp. FileOps fp => fp -> ErrIO [fp]
getDirContNonHidden String
dir
    where
      f :: String -> ErrIO Bool
f = String -> ErrIO Bool
forall fp. DirOps fp => fp -> ErrIO Bool
doesDirExist'

  deleteDirRecursive :: String -> ErrIO ()
deleteDirRecursive String
f =
    do
      Bool
t <- String -> ErrIO Bool
forall fp. DirOps fp => fp -> ErrIO Bool
doesDirExist' String
f
      Bool -> ErrIO () -> ErrIO ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when Bool
t (ErrIO () -> ErrIO ()) -> ErrIO () -> ErrIO ()
forall a b. (a -> b) -> a -> b
$ do
        IO () -> ErrIO ()
forall (m :: * -> *) a.
(MonadError m, MonadIO m, ErrorType m ~ Text) =>
IO a -> m a
callIO (IO () -> ErrIO ()) -> (String -> IO ()) -> String -> ErrIO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> IO ()
D.removeDirectoryRecursive (String -> ErrIO ()) -> String -> ErrIO ()
forall a b. (a -> b) -> a -> b
$ String
f

        [Text] -> ErrIO ()
forall (m :: * -> *). MonadIO m => [Text] -> m ()
putIOwords [Text
"deleted", String -> Text
forall a. Show a => a -> Text
showT String
f]

instance FileOps FilePath where
  doesFileExist' :: String -> ErrIO Bool
doesFileExist' = IO Bool -> ErrIO Bool
forall (m :: * -> *) a.
(MonadError m, MonadIO m, ErrorType m ~ Text) =>
IO a -> m a
callIO (IO Bool -> ErrIO Bool)
-> (String -> IO Bool) -> String -> ErrIO Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> IO Bool
D.doesFileExist

  copyOneFile :: String -> String -> ErrIO ()
copyOneFile String
old String
new = do
    -- source must exist, target must not exist
    Bool
t <- String -> ErrIO Bool
forall fp. FileOps fp => fp -> ErrIO Bool
doesFileExist' String
old
    Bool
t2 <- String -> ErrIO Bool
forall fp. FileOps fp => fp -> ErrIO Bool
doesFileExist' String
new
    if Bool
t Bool -> Bool -> Bool
&& Bool -> Bool
not Bool
t2
      then do
        let dir :: String
dir = String -> String
forall fp. Filenames1 fp => fp -> String
getParentDir String
new -- was takeDir
        Bool
direxist <- String -> ErrIO Bool
forall fp. DirOps fp => fp -> ErrIO Bool
doesDirExist' String
dir
        Bool -> ErrIO () -> ErrIO ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
unless Bool
direxist (ErrIO () -> ErrIO ()) -> ErrIO () -> ErrIO ()
forall a b. (a -> b) -> a -> b
$
          String -> ErrIO ()
forall fp. DirOps fp => fp -> ErrIO ()
createDirIfMissing' String
dir
        IO () -> ErrIO ()
forall (m :: * -> *) a.
(MonadError m, MonadIO m, ErrorType m ~ Text) =>
IO a -> m a
callIO (IO () -> ErrIO ()) -> IO () -> ErrIO ()
forall a b. (a -> b) -> a -> b
$ String -> String -> IO ()
D.copyFile String
old String
new
      else
        if Bool -> Bool
not Bool
t
          then
            [Text] -> ErrIO ()
forall a. [Text] -> ErrIO a
throwErrorT
              [Text
"copyFile source not exist", String -> Text
forall a. Show a => a -> Text
showT String
old]
          else
            if Bool
t2
              then
                [Text] -> ErrIO ()
forall a. [Text] -> ErrIO a
throwErrorT
                  [Text
"copyFile target exist", String -> Text
forall a. Show a => a -> Text
showT String
new]
              else [Text] -> ErrIO ()
forall a. [Text] -> ErrIO a
throwErrorT [Text
"copyOneFile", Text
"other error"]
  copyOneFileOver :: String -> String -> ErrIO ()
copyOneFileOver String
old String
new = do
    -- may overwrite existing target
    Bool
t <- String -> ErrIO Bool
forall fp. FileOps fp => fp -> ErrIO Bool
doesFileExist' String
old
    if Bool
t
      then do
        let dir :: String
dir = String -> String
forall fp. Filenames1 fp => fp -> String
getParentDir String
new -- was takeDir
        Bool
direxist <- String -> ErrIO Bool
forall fp. DirOps fp => fp -> ErrIO Bool
doesDirExist' String
dir
        Bool -> ErrIO () -> ErrIO ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
unless Bool
direxist (ErrIO () -> ErrIO ()) -> ErrIO () -> ErrIO ()
forall a b. (a -> b) -> a -> b
$
          String -> ErrIO ()
forall fp. DirOps fp => fp -> ErrIO ()
createDirIfMissing' String
dir
        IO () -> ErrIO ()
forall (m :: * -> *) a.
(MonadError m, MonadIO m, ErrorType m ~ Text) =>
IO a -> m a
callIO (IO () -> ErrIO ()) -> IO () -> ErrIO ()
forall a b. (a -> b) -> a -> b
$ String -> String -> IO ()
D.copyFile String
old String
new
      else -- not t - not existing source
        [Text] -> ErrIO ()
forall a. [Text] -> ErrIO a
throwErrorT [Text
"copyFileOver source not exist", String -> Text
forall a. Show a => a -> Text
showT String
old]

  getMD5 :: String -> ErrIO (Maybe Text)
getMD5 String
fn =
    do
      FileStatus
status <- String -> ErrIO FileStatus
forall fp. FileOps fp => fp -> ErrIO FileStatus
getSymbolicLinkStatus String
fn
      let regular :: Bool
regular = FileStatus -> Bool
isRegularFile FileStatus
status
      Bool
readable <- String -> (Bool, Bool, Bool) -> ErrIO Bool
forall fp. FileOps fp => fp -> (Bool, Bool, Bool) -> ErrIO Bool
getFileAccess String
fn (Bool
True, Bool
False, Bool
False)
      if Bool
regular Bool -> Bool -> Bool
&& Bool
readable
        then IO (Maybe Text) -> ErrIO (Maybe Text)
forall (m :: * -> *) a.
(MonadError m, MonadIO m, ErrorType m ~ Text) =>
IO a -> m a
callIO (IO (Maybe Text) -> ErrIO (Maybe Text))
-> IO (Maybe Text) -> ErrIO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ do
          ByteString
filedata :: L.ByteString <- String -> IO ByteString
L.readFile String
fn
          let res :: Text
res = MD5Digest -> Text
forall a. Show a => a -> Text
showT (MD5Digest -> Text) -> MD5Digest -> Text
forall a b. (a -> b) -> a -> b
$ ByteString -> MD5Digest
md5 ByteString
filedata
          Maybe Text -> IO (Maybe Text)
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe Text -> IO (Maybe Text)) -> Maybe Text -> IO (Maybe Text)
forall a b. NFData a => (a -> b) -> a -> b
$!! (Text -> Maybe Text
forall a. a -> Maybe a
Just Text
res)
        else [Text] -> ErrIO (Maybe Text)
forall a. [Text] -> ErrIO a
throwErrorT [Text
"getMD5 error file not readable", String -> Text
forall a. Show a => a -> Text
showT String
fn]
      ErrIO (Maybe Text)
-> (ErrorType (ErrorT Text IO) -> ErrIO (Maybe Text))
-> ErrIO (Maybe Text)
forall (m :: * -> *) a.
MonadError m =>
m a -> (ErrorType m -> m a) -> m a
`catchError` \ErrorType (ErrorT Text IO)
e -> do
        [Text] -> ErrIO ()
forall (m :: * -> *). MonadIO m => [Text] -> m ()
putIOwords [Text
"getMD5 in FileStrings.hs", String -> Text
forall a. Show a => a -> Text
showT String
fn, Text -> Text
forall a. Show a => a -> Text
showT Text
ErrorType (ErrorT Text IO)
e]

        [Text] -> ErrIO (Maybe Text)
forall a. [Text] -> ErrIO a
throwErrorT [Text
"getMD5 error for", String -> Text
forall a. Show a => a -> Text
showT String
fn]

  getDirCont :: String -> ErrIO [String]
getDirCont String
fn = Bool -> String -> ErrIO [String]
getDirContAll Bool
True String
fn

  getDirContNonHidden :: String -> ErrIO [String]
getDirContNonHidden String
fp = do
    [String]
r <- Bool -> String -> ErrIO [String]
getDirContAll Bool
False String
fp
    [String] -> ErrIO [String]
forall (m :: * -> *) a. Monad m => a -> m a
return [String]
r

  deleteFile :: String -> ErrIO ()
deleteFile String
f = do
    IO () -> ErrIO ()
forall (m :: * -> *) a.
(MonadError m, MonadIO m, ErrorType m ~ Text) =>
IO a -> m a
callIO (IO () -> ErrIO ()) -> (String -> IO ()) -> String -> ErrIO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> IO ()
D.removeFile (String -> ErrIO ()) -> String -> ErrIO ()
forall a b. (a -> b) -> a -> b
$ String
f

  getAppConfigDirectory :: ErrIO String
getAppConfigDirectory = String -> ErrIO String
forall a. HasCallStack => String -> a
error String
"not implemented" -- do

  getSymbolicLinkStatus :: String -> ErrIO FileStatus
getSymbolicLinkStatus String
fp = do
    FileStatus
st <- IO FileStatus -> ErrIO FileStatus
forall (m :: * -> *) a.
(MonadError m, MonadIO m, ErrorType m ~ Text) =>
IO a -> m a
callIO (IO FileStatus -> ErrIO FileStatus)
-> IO FileStatus -> ErrIO FileStatus
forall a b. (a -> b) -> a -> b
$ String -> IO FileStatus
Posix.getSymbolicLinkStatus String
fp
    FileStatus -> ErrIO FileStatus
forall (m :: * -> *) a. Monad m => a -> m a
return FileStatus
st

  getFileAccess :: String -> (Bool, Bool, Bool) -> ErrIO Bool
getFileAccess String
fp (Bool
r, Bool
w, Bool
e) =
    IO Bool -> ErrIO Bool
forall (m :: * -> *) a.
(MonadError m, MonadIO m, ErrorType m ~ Text) =>
IO a -> m a
callIO (IO Bool -> ErrIO Bool) -> IO Bool -> ErrIO Bool
forall a b. (a -> b) -> a -> b
$
      String -> Bool -> Bool -> Bool -> IO Bool
Posix.fileAccess String
fp Bool
r Bool
w Bool
e

  getFileModificationTime :: String -> ErrIO EpochTime
getFileModificationTime String
fp = do
    FileStatus
stat :: Posix.FileStatus <- String -> ErrIO FileStatus
getFileStatus' String
fp
    let time :: EpochTime
time = FileStatus -> EpochTime
getModificationTimeFromStatus FileStatus
stat
    EpochTime -> ErrIO EpochTime
forall (m :: * -> *) a. Monad m => a -> m a
return EpochTime
time

  openFile2handle :: String -> IOMode -> ErrIO Handle
openFile2handle String
fp IOMode
mode =
    IO Handle -> ErrIO Handle
forall (m :: * -> *) a.
(MonadError m, MonadIO m, ErrorType m ~ Text) =>
IO a -> m a
callIO (IO Handle -> ErrIO Handle) -> IO Handle -> ErrIO Handle
forall a b. (a -> b) -> a -> b
$ String -> IOMode -> IO Handle
SIO.openFile String
fp IOMode
mode

getDirContAll :: Bool -> String -> ErrIO [String]
getDirContAll Bool
hiddenFlag String
fn = do
  -- the hiddenFlag must be true to include them
  Bool
testDir <- String -> ErrIO Bool
forall fp. DirOps fp => fp -> ErrIO Bool
doesDirExist' String
fn
  Bool
readExec <- String -> (Bool, Bool, Bool) -> ErrIO Bool
forall fp. FileOps fp => fp -> (Bool, Bool, Bool) -> ErrIO Bool
getFileAccess String
fn (Bool
True, Bool
False, Bool
True)
  if Bool
testDir Bool -> Bool -> Bool
&& Bool
readExec
    then do
      [String]
r <- IO [String] -> ErrIO [String]
forall (m :: * -> *) a.
(MonadError m, MonadIO m, ErrorType m ~ Text) =>
IO a -> m a
callIO (IO [String] -> ErrIO [String])
-> (String -> IO [String]) -> String -> ErrIO [String]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> IO [String]
D.listDirectory (String -> ErrIO [String]) -> String -> ErrIO [String]
forall a b. (a -> b) -> a -> b
$ String
fn
      let r2 :: [String]
r2 = (String -> Bool) -> [String] -> [String]
forall a. (a -> Bool) -> [a] -> [a]
filter (\String
file' -> String
file' String -> String -> Bool
forall a. Eq a => a -> a -> Bool
/= String
"." Bool -> Bool -> Bool
&& String
file' String -> String -> Bool
forall a. Eq a => a -> a -> Bool
/= String
"..") [String]
r
      let r3 :: [String]
r3 =
            if Bool
hiddenFlag
              then [String]
r2
              else (String -> Bool) -> [String] -> [String]
forall a. (a -> Bool) -> [a] -> [a]
filter (Bool -> Bool
not (Bool -> Bool) -> (String -> Bool) -> String -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> String -> Bool
forall a. Eq a => [a] -> [a] -> Bool
isPrefixOf String
".") [String]
r2
      let r4 :: [String]
r4 = (String -> String) -> [String] -> [String]
forall a b. (a -> b) -> [a] -> [b]
map (String
fn String -> String -> FileResultT String String
forall fp file.
Filenames3 fp file =>
fp -> file -> FileResultT fp file
</>) [String]
r3
      [String] -> ErrIO [String]
forall (m :: * -> *) a. Monad m => a -> m a
return [String]
r4
    else
      [Text] -> ErrIO [String]
forall a. [Text] -> ErrIO a
throwErrorT
        [ Text
"getDirCont not exist or not readable",
          String -> Text
forall a. Show a => a -> Text
showT String
fn,
          Bool -> Text
forall a. Show a => a -> Text
showT Bool
testDir,
          Bool -> Text
forall a. Show a => a -> Text
showT Bool
readExec
        ]

instance FileSystemOps (Path ar df) where
  getPermissions' :: Path ar df -> ErrIO Permissions
getPermissions' = Path ar df -> ErrIO Permissions
forall (m :: * -> *) b t. MonadIO m => Path b t -> m Permissions
PathIO.getPermissions (Path ar df -> ErrIO Permissions)
-> (Path ar df -> Path ar df) -> Path ar df -> ErrIO Permissions
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Path ar df -> Path ar df
forall a. a -> a
unPath
  checkSymbolicLink :: Path ar df -> ErrIO Bool
checkSymbolicLink Path ar df
fp = IO Bool -> ErrIO Bool
forall (m :: * -> *) a.
(MonadError m, MonadIO m, ErrorType m ~ Text) =>
IO a -> m a
callIO (IO Bool -> ErrIO Bool) -> IO Bool -> ErrIO Bool
forall a b. (a -> b) -> a -> b
$ String -> IO Bool
D.pathIsSymbolicLink (Path ar df -> String
forall b t. Path b t -> String
unL Path ar df
fp)

instance DirOps (Path Abs Dir) where
  doesDirExist' :: Path Abs Dir -> ErrIO Bool
doesDirExist' = Path Abs Dir -> ErrIO Bool
forall (m :: * -> *) b. MonadIO m => Path b Dir -> m Bool
PathIO.doesDirExist

  createDir' :: Path Abs Dir -> ErrIO ()
createDir' = Path Abs Dir -> ErrIO ()
forall (m :: * -> *) b. MonadIO m => Path b Dir -> m ()
PathIO.createDir (Path Abs Dir -> ErrIO ())
-> (Path Abs Dir -> Path Abs Dir) -> Path Abs Dir -> ErrIO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Path Abs Dir -> Path Abs Dir
forall a. a -> a
unPath

  renameDir' :: Path Abs Dir -> Path Abs Dir -> ErrIO ()
renameDir' Path Abs Dir
old Path Abs Dir
new =
    -- :: fp -> fp ->  ErrIO Text
    Path Abs Dir -> Path Abs Dir -> ErrIO ()
forall (m :: * -> *) b0 b1.
MonadIO m =>
Path b0 Dir -> Path b1 Dir -> m ()
PathIO.renameDir (Path Abs Dir -> Path Abs Dir
forall a. a -> a
unPath Path Abs Dir
old) (Path Abs Dir -> Path Abs Dir
forall a. a -> a
unPath Path Abs Dir
new)

  getDirectoryDirs' :: Path Abs Dir -> ErrIO [Path Abs Dir]
getDirectoryDirs' Path Abs Dir
dir = do
    [String]
res <- (String -> ErrIO Bool) -> [String] -> ErrIO [String]
forall (m :: * -> *) a.
Applicative m =>
(a -> m Bool) -> [a] -> m [a]
filterM String -> ErrIO Bool
f ([String] -> ErrIO [String]) -> ErrIO [String] -> ErrIO [String]
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< String -> ErrIO [String]
forall fp. FileOps fp => fp -> ErrIO [fp]
getDirCont (Path Abs Dir -> String
forall b t. Path b t -> String
toFilePath Path Abs Dir
dir)
    [Path Abs Dir] -> ErrIO [Path Abs Dir]
forall (m :: * -> *) a. Monad m => a -> m a
return ([Path Abs Dir] -> ErrIO [Path Abs Dir])
-> ([String] -> [Path Abs Dir]) -> [String] -> ErrIO [Path Abs Dir]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (String -> Path Abs Dir) -> [String] -> [Path Abs Dir]
forall a b. (a -> b) -> [a] -> [b]
map String -> Path Abs Dir
makeAbsDir ([String] -> ErrIO [Path Abs Dir])
-> [String] -> ErrIO [Path Abs Dir]
forall a b. (a -> b) -> a -> b
$ [String]
res
    where
      f :: String -> ErrIO Bool
f = String -> ErrIO Bool
forall fp. DirOps fp => fp -> ErrIO Bool
doesDirExist'
  getDirectoryDirsNonHidden' :: Path Abs Dir -> ErrIO [Path Abs Dir]
getDirectoryDirsNonHidden' Path Abs Dir
dir = do
    [String]
res <- (String -> ErrIO Bool) -> [String] -> ErrIO [String]
forall (m :: * -> *) a.
Applicative m =>
(a -> m Bool) -> [a] -> m [a]
filterM String -> ErrIO Bool
f ([String] -> ErrIO [String]) -> ErrIO [String] -> ErrIO [String]
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< String -> ErrIO [String]
forall fp. FileOps fp => fp -> ErrIO [fp]
getDirContNonHidden (Path Abs Dir -> String
forall b t. Path b t -> String
toFilePath Path Abs Dir
dir)
    [Path Abs Dir] -> ErrIO [Path Abs Dir]
forall (m :: * -> *) a. Monad m => a -> m a
return ([Path Abs Dir] -> ErrIO [Path Abs Dir])
-> ([String] -> [Path Abs Dir]) -> [String] -> ErrIO [Path Abs Dir]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (String -> Path Abs Dir) -> [String] -> [Path Abs Dir]
forall a b. (a -> b) -> [a] -> [b]
map String -> Path Abs Dir
makeAbsDir ([String] -> ErrIO [Path Abs Dir])
-> [String] -> ErrIO [Path Abs Dir]
forall a b. (a -> b) -> a -> b
$ [String]
res
    where
      f :: String -> ErrIO Bool
f = String -> ErrIO Bool
forall fp. DirOps fp => fp -> ErrIO Bool
doesDirExist'

  createDirIfMissing' :: Path Abs Dir -> ErrIO ()
createDirIfMissing' = Bool -> Path Abs Dir -> ErrIO ()
forall (m :: * -> *) b. MonadIO m => Bool -> Path b Dir -> m ()
PathIO.createDirIfMissing Bool
True (Path Abs Dir -> ErrIO ())
-> (Path Abs Dir -> Path Abs Dir) -> Path Abs Dir -> ErrIO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Path Abs Dir -> Path Abs Dir
forall a. a -> a
unPath

  copyDirRecursive :: Path Abs Dir -> Path Abs Dir -> ErrIO ()
copyDirRecursive Path Abs Dir
old Path Abs Dir
new = Path Abs Dir -> Path Abs Dir -> ErrIO ()
forall (m :: * -> *) b0 b1.
(MonadIO m, MonadCatch m) =>
Path b0 Dir -> Path b1 Dir -> m ()
PathIO.copyDirRecur (Path Abs Dir -> Path Abs Dir
forall a. a -> a
unPath Path Abs Dir
old) (Path Abs Dir -> Path Abs Dir
forall a. a -> a
unPath Path Abs Dir
new)

  deleteDirRecursive :: Path Abs Dir -> ErrIO ()
deleteDirRecursive Path Abs Dir
f = String -> ErrIO ()
forall fp. DirOps fp => fp -> ErrIO ()
deleteDirRecursive (Path Abs Dir -> String
forall b t. Path b t -> String
unL Path Abs Dir
f)

instance DirOps (Path Rel Dir) where
  doesDirExist' :: Path Rel Dir -> ErrIO Bool
doesDirExist' = Path Rel Dir -> ErrIO Bool
forall (m :: * -> *) b. MonadIO m => Path b Dir -> m Bool
PathIO.doesDirExist

  createDir' :: Path Rel Dir -> ErrIO ()
createDir' = Path Rel Dir -> ErrIO ()
forall (m :: * -> *) b. MonadIO m => Path b Dir -> m ()
PathIO.createDir (Path Rel Dir -> ErrIO ())
-> (Path Rel Dir -> Path Rel Dir) -> Path Rel Dir -> ErrIO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Path Rel Dir -> Path Rel Dir
forall a. a -> a
unPath

  renameDir' :: Path Rel Dir -> Path Rel Dir -> ErrIO ()
renameDir' Path Rel Dir
old Path Rel Dir
new =
    Path Rel Dir -> Path Rel Dir -> ErrIO ()
forall (m :: * -> *) b0 b1.
MonadIO m =>
Path b0 Dir -> Path b1 Dir -> m ()
PathIO.renameDir (Path Rel Dir -> Path Rel Dir
forall a. a -> a
unPath Path Rel Dir
old) (Path Rel Dir -> Path Rel Dir
forall a. a -> a
unPath Path Rel Dir
new)

  getDirectoryDirs' :: Path Rel Dir -> ErrIO [Path Rel Dir]
getDirectoryDirs' Path Rel Dir
dir = do
    [String]
res <- (String -> ErrIO Bool) -> [String] -> ErrIO [String]
forall (m :: * -> *) a.
Applicative m =>
(a -> m Bool) -> [a] -> m [a]
filterM String -> ErrIO Bool
f ([String] -> ErrIO [String]) -> ErrIO [String] -> ErrIO [String]
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< String -> ErrIO [String]
forall fp. FileOps fp => fp -> ErrIO [fp]
getDirCont (Path Rel Dir -> String
forall b t. Path b t -> String
toFilePath Path Rel Dir
dir)
    [Path Rel Dir] -> ErrIO [Path Rel Dir]
forall (m :: * -> *) a. Monad m => a -> m a
return ([Path Rel Dir] -> ErrIO [Path Rel Dir])
-> ([String] -> [Path Rel Dir]) -> [String] -> ErrIO [Path Rel Dir]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (String -> Path Rel Dir) -> [String] -> [Path Rel Dir]
forall a b. (a -> b) -> [a] -> [b]
map String -> Path Rel Dir
makeRelDir ([String] -> ErrIO [Path Rel Dir])
-> [String] -> ErrIO [Path Rel Dir]
forall a b. (a -> b) -> a -> b
$ [String]
res
    where
      f :: String -> ErrIO Bool
f = String -> ErrIO Bool
forall fp. DirOps fp => fp -> ErrIO Bool
doesDirExist'

  getDirectoryDirsNonHidden' :: Path Rel Dir -> ErrIO [Path Rel Dir]
getDirectoryDirsNonHidden' Path Rel Dir
dir = do
    [String]
res <- (String -> ErrIO Bool) -> [String] -> ErrIO [String]
forall (m :: * -> *) a.
Applicative m =>
(a -> m Bool) -> [a] -> m [a]
filterM String -> ErrIO Bool
f ([String] -> ErrIO [String]) -> ErrIO [String] -> ErrIO [String]
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< String -> ErrIO [String]
forall fp. FileOps fp => fp -> ErrIO [fp]
getDirContNonHidden (Path Rel Dir -> String
forall b t. Path b t -> String
toFilePath Path Rel Dir
dir)
    [Path Rel Dir] -> ErrIO [Path Rel Dir]
forall (m :: * -> *) a. Monad m => a -> m a
return ([Path Rel Dir] -> ErrIO [Path Rel Dir])
-> ([String] -> [Path Rel Dir]) -> [String] -> ErrIO [Path Rel Dir]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (String -> Path Rel Dir) -> [String] -> [Path Rel Dir]
forall a b. (a -> b) -> [a] -> [b]
map String -> Path Rel Dir
makeRelDir ([String] -> ErrIO [Path Rel Dir])
-> [String] -> ErrIO [Path Rel Dir]
forall a b. (a -> b) -> a -> b
$ [String]
res
    where
      f :: String -> ErrIO Bool
f = String -> ErrIO Bool
forall fp. DirOps fp => fp -> ErrIO Bool
doesDirExist'

  createDirIfMissing' :: Path Rel Dir -> ErrIO ()
createDirIfMissing' = Bool -> Path Rel Dir -> ErrIO ()
forall (m :: * -> *) b. MonadIO m => Bool -> Path b Dir -> m ()
PathIO.createDirIfMissing Bool
True (Path Rel Dir -> ErrIO ())
-> (Path Rel Dir -> Path Rel Dir) -> Path Rel Dir -> ErrIO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Path Rel Dir -> Path Rel Dir
forall a. a -> a
unPath

  copyDirRecursive :: Path Rel Dir -> Path Rel Dir -> ErrIO ()
copyDirRecursive Path Rel Dir
old Path Rel Dir
new = Path Rel Dir -> Path Rel Dir -> ErrIO ()
forall (m :: * -> *) b0 b1.
(MonadIO m, MonadCatch m) =>
Path b0 Dir -> Path b1 Dir -> m ()
PathIO.copyDirRecur (Path Rel Dir -> Path Rel Dir
forall a. a -> a
unPath Path Rel Dir
old) (Path Rel Dir -> Path Rel Dir
forall a. a -> a
unPath Path Rel Dir
new)

  deleteDirRecursive :: Path Rel Dir -> ErrIO ()
deleteDirRecursive Path Rel Dir
f = String -> ErrIO ()
forall fp. DirOps fp => fp -> ErrIO ()
deleteDirRecursive (Path Rel Dir -> String
forall b t. Path b t -> String
unL Path Rel Dir
f)

instance (Show (Path ar File)) => FileOps (Path ar File) where
  doesFileExist' :: Path ar File -> ErrIO Bool
doesFileExist' = Path ar File -> ErrIO Bool
forall (m :: * -> *) b. MonadIO m => Path b File -> m Bool
PathIO.doesFileExist (Path ar File -> ErrIO Bool)
-> (Path ar File -> Path ar File) -> Path ar File -> ErrIO Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Path ar File -> Path ar File
forall a. a -> a
unPath

  copyOneFile :: Path ar File -> Path ar File -> ErrIO ()
copyOneFile Path ar File
old Path ar File
new = String -> String -> ErrIO ()
forall fp. FileOps fp => fp -> fp -> ErrIO ()
copyOneFile (Path ar File -> String
forall b t. Path b t -> String
unL Path ar File
old) (Path ar File -> String
forall b t. Path b t -> String
unL Path ar File
new)
  copyOneFileOver :: Path ar File -> Path ar File -> ErrIO ()
copyOneFileOver Path ar File
old Path ar File
new = String -> String -> ErrIO ()
forall fp. FileOps fp => fp -> fp -> ErrIO ()
copyOneFileOver (Path ar File -> String
forall b t. Path b t -> String
unL Path ar File
old) (Path ar File -> String
forall b t. Path b t -> String
unL Path ar File
new)
  renameOneFile :: Path ar File -> Path ar File -> ErrIO ()
renameOneFile Path ar File
old Path ar File
new =
    Path ar File -> Path ar File -> ErrIO ()
forall (m :: * -> *) b0 b1.
MonadIO m =>
Path b0 File -> Path b1 File -> m ()
PathIO.renameFile (Path ar File -> Path ar File
forall a. a -> a
unPath Path ar File
old) (Path ar File -> Path ar File
forall a. a -> a
unPath Path ar File
new)

  deleteFile :: Path ar File -> ErrIO ()
deleteFile Path ar File
f = String -> ErrIO ()
forall fp. FileOps fp => fp -> ErrIO ()
deleteFile (Path ar File -> String
forall b t. Path b t -> String
unL Path ar File
f)

  getMD5 :: Path ar File -> ErrIO (Maybe Text)
getMD5 Path ar File
fp = String -> ErrIO (Maybe Text)
forall fp. FileOps fp => fp -> ErrIO (Maybe Text)
getMD5 (Path ar File -> String
forall b t. Path b t -> String
unL Path ar File
fp)

  getDirCont :: Path ar File -> ErrIO [Path ar File]
getDirCont Path ar File
fp =
    String -> ErrIO [Path ar File]
forall a. HasCallStack => String -> a
error String
"getDirCont cannot be implemented for Path"
  getDirContNonHidden :: Path ar File -> ErrIO [Path ar File]
getDirContNonHidden Path ar File
fp =
    String -> ErrIO [Path ar File]
forall a. HasCallStack => String -> a
error String
"getDirContentNonHidden cannot be implemented for Path"

  getFileModificationTime :: Path ar File -> ErrIO EpochTime
getFileModificationTime Path ar File
fp = String -> ErrIO EpochTime
forall fp. FileOps fp => fp -> ErrIO EpochTime
getFileModificationTime (Path ar File -> String
forall b t. Path b t -> String
unL Path ar File
fp)

  openFile2handle :: Path ar File -> IOMode -> ErrIO Handle
openFile2handle Path ar File
fp IOMode
mode = String -> IOMode -> ErrIO Handle
forall fp. FileOps fp => fp -> IOMode -> ErrIO Handle
openFile2handle (Path ar File -> String
forall b t. Path b t -> String
unL Path ar File
fp) IOMode
mode

  getFileAccess :: Path ar File -> (Bool, Bool, Bool) -> ErrIO Bool
getFileAccess Path ar File
fp (Bool
r, Bool
w, Bool
e) =
    IO Bool -> ErrIO Bool
forall (m :: * -> *) a.
(MonadError m, MonadIO m, ErrorType m ~ Text) =>
IO a -> m a
callIO
      ( do
          String -> Bool -> Bool -> Bool -> IO Bool
Posix.fileAccess (Path ar File -> String
forall b t. Path b t -> String
unL Path ar File
fp) Bool
r Bool
w Bool
e
          IO Bool -> (ErrorType IO -> IO Bool) -> IO Bool
forall (m :: * -> *) a.
MonadError m =>
m a -> (ErrorType m -> m a) -> m a
`catchError` \ErrorType IO
e -> do
            [Text] -> IO ()
forall (m :: * -> *). MonadIO m => [Text] -> m ()
putIOwords [Text
"getFileAccess error", Path ar File -> Text
forall a. Show a => a -> Text
showT Path ar File
fp, String -> Text
s2t (String -> Text) -> String -> Text
forall a b. (a -> b) -> a -> b
$ IOError -> String
forall a. Show a => a -> String
show IOError
ErrorType IO
e]
            Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
False
      )

unL :: Path b t -> String
unL = Path b t -> String
forall b t. Path b t -> String
FN.toFilePath

readFileT :: Path ar File -> ErrIO Text
readFileT :: Path ar File -> ErrIO Text
readFileT Path ar File
fp = IO Text -> ErrIO Text
forall (m :: * -> *) a.
(MonadError m, MonadIO m, ErrorType m ~ Text) =>
IO a -> m a
callIO (IO Text -> ErrIO Text)
-> (Path ar File -> IO Text) -> Path ar File -> ErrIO Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> IO Text
T.readFile (String -> IO Text)
-> (Path ar File -> String) -> Path ar File -> IO Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Path ar File -> String
forall b t. Path b t -> String
unL (Path ar File -> ErrIO Text) -> Path ar File -> ErrIO Text
forall a b. (a -> b) -> a -> b
$ Path ar File
fp

writeFileT :: Path ar File -> Text -> ErrIO ()
writeFileT :: Path ar File -> Text -> ErrIO ()
writeFileT Path ar File
fp Text
st = IO () -> ErrIO ()
forall (m :: * -> *) a.
(MonadError m, MonadIO m, ErrorType m ~ Text) =>
IO a -> m a
callIO (IO () -> ErrIO ()) -> IO () -> ErrIO ()
forall a b. (a -> b) -> a -> b
$ String -> Text -> IO ()
T.writeFile (Path ar File -> String
forall b t. Path b t -> String
unL Path ar File
fp) Text
st

-- attention - does not create file if not existing

instance (Show (Path ar File)) => FileOps2 (Path ar File) String where
  readFile2 :: Path ar File -> ErrIO String
readFile2 Path ar File
fp = IO String -> ErrIO String
forall (m :: * -> *) a.
(MonadError m, MonadIO m, ErrorType m ~ Text) =>
IO a -> m a
callIO (IO String -> ErrIO String) -> IO String -> ErrIO String
forall a b. (a -> b) -> a -> b
$ String -> IO String
readFile (Path ar File -> String
forall b t. Path b t -> String
unL Path ar File
fp)

  -- a strict read (does cloes?)
  writeFile2 :: Path ar File -> String -> ErrIO ()
writeFile2 Path ar File
fp String
st = IO () -> ErrIO ()
forall (m :: * -> *) a.
(MonadError m, MonadIO m, ErrorType m ~ Text) =>
IO a -> m a
callIO (IO () -> ErrIO ()) -> IO () -> ErrIO ()
forall a b. (a -> b) -> a -> b
$ String -> String -> IO ()
writeFile (Path ar File -> String
forall b t. Path b t -> String
unL Path ar File
fp) String
st
  appendFile2 :: Path ar File -> String -> ErrIO ()
appendFile2 Path ar File
fp String
st = IO () -> ErrIO ()
forall (m :: * -> *) a.
(MonadError m, MonadIO m, ErrorType m ~ Text) =>
IO a -> m a
callIO (IO () -> ErrIO ()) -> IO () -> ErrIO ()
forall a b. (a -> b) -> a -> b
$ String -> String -> IO ()
appendFile (Path ar File -> String
forall b t. Path b t -> String
unL Path ar File
fp) String
st

instance (Show (Path ar File)) => FileOps2 (Path ar File) Text where
  readFile2 :: Path ar File -> ErrIO Text
readFile2 Path ar File
fp = String -> ErrIO Text
forall fp fc. FileOps2 fp fc => fp -> ErrIO fc
readFile2 (Path ar File -> String
forall b t. Path b t -> String
unL Path ar File
fp)

  writeFile2 :: Path ar File -> Text -> ErrIO ()
writeFile2 Path ar File
fp Text
st = String -> Text -> ErrIO ()
forall fp fc. FileOps2 fp fc => fp -> fc -> ErrIO ()
writeFile2 (Path ar File -> String
forall b t. Path b t -> String
unL Path ar File
fp) Text
st
  appendFile2 :: Path ar File -> Text -> ErrIO ()
appendFile2 Path ar File
fp Text
st = String -> Text -> ErrIO ()
forall fp fc. FileOps2 fp fc => fp -> fc -> ErrIO ()
appendFile2 (Path ar File -> String
forall b t. Path b t -> String
unL Path ar File
fp) Text
st

  writeFileOrCreate2 :: Path ar File -> Text -> ErrIO ()
writeFileOrCreate2 Path ar File
filepath Text
st = do
    let dir :: String
dir = Path ar File -> String
forall fp. Filenames1 fp => fp -> String
getParentDir Path ar File
filepath

    String -> ErrIO ()
forall fp. DirOps fp => fp -> ErrIO ()
createDirIfMissing' String
dir
    Bool -> ErrIO () -> ErrIO ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when Bool
False (ErrIO () -> ErrIO ()) -> ErrIO () -> ErrIO ()
forall a b. (a -> b) -> a -> b
$ [Text] -> ErrIO ()
forall (m :: * -> *). MonadIO m => [Text] -> m ()
putIOwords [Text
"writeFileOrCreate2 dir created", String -> Text
forall a. Show a => a -> Text
showT String
dir]
    Bool
t <- String -> ErrIO Bool
forall fp. DirOps fp => fp -> ErrIO Bool
doesDirExist' String
dir
    Bool -> ErrIO () -> ErrIO ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when Bool
False (ErrIO () -> ErrIO ()) -> ErrIO () -> ErrIO ()
forall a b. (a -> b) -> a -> b
$ [Text] -> ErrIO ()
forall (m :: * -> *). MonadIO m => [Text] -> m ()
putIOwords [Text
"writeFileOrCreate2 dir test", Bool -> Text
forall a. Show a => a -> Text
showT Bool
t]
    Path ar File -> Text -> ErrIO ()
forall fp fc. FileOps2 fp fc => fp -> fc -> ErrIO ()
writeFile2 Path ar File
filepath Text
st
    Bool -> ErrIO () -> ErrIO ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when Bool
False (ErrIO () -> ErrIO ()) -> ErrIO () -> ErrIO ()
forall a b. (a -> b) -> a -> b
$ [Text] -> ErrIO ()
forall (m :: * -> *). MonadIO m => [Text] -> m ()
putIOwords [Text
"writeFileOrCreate2 file written", Path ar File -> Text
forall a. Show a => a -> Text
showT Path ar File
filepath]

instance FileOps2 FilePath Text where
  readFile2 :: String -> ErrIO Text
readFile2 String
fp = IO Text -> ErrIO Text
forall (m :: * -> *) a.
(MonadError m, MonadIO m, ErrorType m ~ Text) =>
IO a -> m a
callIO (IO Text -> ErrIO Text) -> IO Text -> ErrIO Text
forall a b. (a -> b) -> a -> b
$ String -> IO Text
T.readFile String
fp
  writeFile2 :: String -> Text -> ErrIO ()
writeFile2 String
fp Text
st = IO () -> ErrIO ()
forall (m :: * -> *) a.
(MonadError m, MonadIO m, ErrorType m ~ Text) =>
IO a -> m a
callIO (IO () -> ErrIO ()) -> IO () -> ErrIO ()
forall a b. (a -> b) -> a -> b
$ String -> Text -> IO ()
T.writeFile String
fp Text
st
  appendFile2 :: String -> Text -> ErrIO ()
appendFile2 String
fp Text
st = IO () -> ErrIO ()
forall (m :: * -> *) a.
(MonadError m, MonadIO m, ErrorType m ~ Text) =>
IO a -> m a
callIO (IO () -> ErrIO ()) -> IO () -> ErrIO ()
forall a b. (a -> b) -> a -> b
$ String -> Text -> IO ()
T.appendFile String
fp Text
st

instance FileOps2 FilePath L.ByteString where
  readFile2 :: String -> ErrIO ByteString
readFile2 String
fp = IO ByteString -> ErrIO ByteString
forall (m :: * -> *) a.
(MonadError m, MonadIO m, ErrorType m ~ Text) =>
IO a -> m a
callIO (IO ByteString -> ErrIO ByteString)
-> IO ByteString -> ErrIO ByteString
forall a b. (a -> b) -> a -> b
$ String -> IO ByteString
L.readFile String
fp
  writeFile2 :: String -> ByteString -> ErrIO ()
writeFile2 String
fp ByteString
st = IO () -> ErrIO ()
forall (m :: * -> *) a.
(MonadError m, MonadIO m, ErrorType m ~ Text) =>
IO a -> m a
callIO (IO () -> ErrIO ()) -> IO () -> ErrIO ()
forall a b. (a -> b) -> a -> b
$ String -> ByteString -> IO ()
L.writeFile String
fp ByteString
st
  appendFile2 :: String -> ByteString -> ErrIO ()
appendFile2 String
fp ByteString
st = IO () -> ErrIO ()
forall (m :: * -> *) a.
(MonadError m, MonadIO m, ErrorType m ~ Text) =>
IO a -> m a
callIO (IO () -> ErrIO ()) -> IO () -> ErrIO ()
forall a b. (a -> b) -> a -> b
$ String -> ByteString -> IO ()
L.appendFile String
fp ByteString
st

instance (Show (Path ar File)) => FileOps2 (Path ar File) L.ByteString where
  readFile2 :: Path ar File -> ErrIO ByteString
readFile2 Path ar File
fp = IO ByteString -> ErrIO ByteString
forall (m :: * -> *) a.
(MonadError m, MonadIO m, ErrorType m ~ Text) =>
IO a -> m a
callIO (IO ByteString -> ErrIO ByteString)
-> IO ByteString -> ErrIO ByteString
forall a b. (a -> b) -> a -> b
$ String -> IO ByteString
L.readFile (String -> IO ByteString)
-> (Path ar File -> String) -> Path ar File -> IO ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Path ar File -> String
forall b t. Path b t -> String
unL (Path ar File -> IO ByteString) -> Path ar File -> IO ByteString
forall a b. (a -> b) -> a -> b
$ Path ar File
fp
  writeFile2 :: Path ar File -> ByteString -> ErrIO ()
writeFile2 Path ar File
fp ByteString
st = IO () -> ErrIO ()
forall (m :: * -> *) a.
(MonadError m, MonadIO m, ErrorType m ~ Text) =>
IO a -> m a
callIO (IO () -> ErrIO ()) -> IO () -> ErrIO ()
forall a b. (a -> b) -> a -> b
$ String -> ByteString -> IO ()
L.writeFile (Path ar File -> String
forall b t. Path b t -> String
unL Path ar File
fp) ByteString
st
  appendFile2 :: Path ar File -> ByteString -> ErrIO ()
appendFile2 Path ar File
fp ByteString
st = IO () -> ErrIO ()
forall (m :: * -> *) a.
(MonadError m, MonadIO m, ErrorType m ~ Text) =>
IO a -> m a
callIO (IO () -> ErrIO ()) -> IO () -> ErrIO ()
forall a b. (a -> b) -> a -> b
$ String -> ByteString -> IO ()
L.appendFile (Path ar File -> String
forall b t. Path b t -> String
unL Path ar File
fp) ByteString
st

instance FileOps2a FilePath FilePath where
  getDirContentFiles :: String -> ErrIO [String]
getDirContentFiles String
dir =
    (String -> ErrIO Bool) -> [String] -> ErrIO [String]
forall (m :: * -> *) a.
Applicative m =>
(a -> m Bool) -> [a] -> m [a]
filterM String -> ErrIO Bool
forall fp. FileOps fp => fp -> ErrIO Bool
doesFileExist'
      ([String] -> ErrIO [String]) -> ErrIO [String] -> ErrIO [String]
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< String -> ErrIO [String]
forall fp. FileOps fp => fp -> ErrIO [fp]
getDirCont String
dir

  getDirContentNonHiddenFiles :: String -> ErrIO [String]
getDirContentNonHiddenFiles String
dir =
    (String -> ErrIO Bool) -> [String] -> ErrIO [String]
forall (m :: * -> *) a.
Applicative m =>
(a -> m Bool) -> [a] -> m [a]
filterM String -> ErrIO Bool
forall fp. FileOps fp => fp -> ErrIO Bool
doesFileExist'
      ([String] -> ErrIO [String]) -> ErrIO [String] -> ErrIO [String]
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< String -> ErrIO [String]
forall fp. FileOps fp => fp -> ErrIO [fp]
getDirContNonHidden String
dir

instance FileOps2a (Path Abs Dir) (Path Abs File) where
  getDirContentFiles :: Path Abs Dir -> ErrIO [Path Abs File]
getDirContentFiles Path Abs Dir
dir = do
    [String]
res <- String -> ErrIO [String]
forall fd ff. FileOps2a fd ff => fd -> ErrIO [ff]
getDirContentFiles (Path Abs Dir -> String
forall b t. Path b t -> String
toFilePath Path Abs Dir
dir)
    [Path Abs File] -> ErrIO [Path Abs File]
forall (m :: * -> *) a. Monad m => a -> m a
return ((String -> Path Abs File) -> [String] -> [Path Abs File]
forall a b. (a -> b) -> [a] -> [b]
map String -> Path Abs File
makeAbsFile [String]
res)
  getDirContentNonHiddenFiles :: Path Abs Dir -> ErrIO [Path Abs File]
getDirContentNonHiddenFiles Path Abs Dir
dir = do
    [String]
res <- String -> ErrIO [String]
forall fd ff. FileOps2a fd ff => fd -> ErrIO [ff]
getDirContentNonHiddenFiles (Path Abs Dir -> String
forall b t. Path b t -> String
toFilePath Path Abs Dir
dir)
    [Path Abs File] -> ErrIO [Path Abs File]
forall (m :: * -> *) a. Monad m => a -> m a
return ((String -> Path Abs File) -> [String] -> [Path Abs File]
forall a b. (a -> b) -> [a] -> [b]
map String -> Path Abs File
makeAbsFile [String]
res)

instance FileOps2a (Path Rel Dir) (Path Rel File) where
  getDirContentFiles :: Path Rel Dir -> ErrIO [Path Rel File]
getDirContentFiles Path Rel Dir
dir = do
    [String]
res <- String -> ErrIO [String]
forall fd ff. FileOps2a fd ff => fd -> ErrIO [ff]
getDirContentFiles (Path Rel Dir -> String
forall b t. Path b t -> String
toFilePath Path Rel Dir
dir)
    [Path Rel File] -> ErrIO [Path Rel File]
forall (m :: * -> *) a. Monad m => a -> m a
return ((String -> Path Rel File) -> [String] -> [Path Rel File]
forall a b. (a -> b) -> [a] -> [b]
map String -> Path Rel File
makeRelFile [String]
res)
  getDirContentNonHiddenFiles :: Path Rel Dir -> ErrIO [Path Rel File]
getDirContentNonHiddenFiles Path Rel Dir
dir = do
    [String]
res <- String -> ErrIO [String]
forall fd ff. FileOps2a fd ff => fd -> ErrIO [ff]
getDirContentNonHiddenFiles (Path Rel Dir -> String
forall b t. Path b t -> String
toFilePath Path Rel Dir
dir)
    [Path Rel File] -> ErrIO [Path Rel File]
forall (m :: * -> *) a. Monad m => a -> m a
return ((String -> Path Rel File) -> [String] -> [Path Rel File]
forall a b. (a -> b) -> [a] -> [b]
map String -> Path Rel File
makeRelFile [String]
res)