module System.FilePath.FilePather.FilePathPredicate
(
FilePathPredicate(..)
) where
import qualified System.FilePath as P
import System.FilePath.FilePather.RecursePredicate
import System.FilePath.FilePather.FilterPredicate
import Control.Monad
import qualified Data.Foldable as F
class FilePathPredicate f where
always ::
Monad g =>
f g
never ::
Monad g =>
f g
(.&&.) ::
Monad g =>
f g
-> f g
-> f g
(.||.) ::
Monad g =>
f g
-> f g
-> f g
(.!.) ::
Monad g =>
f g
-> f g
anyof ::
(F.Foldable t, Monad g) =>
t (f g)
-> f g
anyof =
F.foldr (.||.) never
allof ::
(F.Foldable t, Monad g) =>
t (f g)
-> f g
allof =
F.foldr (.&&.) always
extension ::
Monad g =>
(FilePath -> Bool)
-> f g
extensionEq ::
Monad g =>
FilePath
-> f g
extensionEq p =
extension (== p)
extensionOneof ::
(F.Foldable t, Monad g) =>
t FilePath
-> f g
extensionOneof =
F.foldr (\a b -> extensionEq a .||. b) never
extensionNoneof ::
(F.Foldable t, Monad g) =>
t FilePath
-> f g
extensionNoneof =
F.foldr (\a b -> (.!.) (extensionEq a) .&&. b) always
directory ::
Monad g =>
(FilePath -> Bool)
-> f g
hasExtension ::
Monad g =>
f g
hasExtension =
(.!.) notHasExtension
notHasExtension ::
Monad g =>
f g
notHasExtension =
(.!.) hasExtension
splitExtension ::
Monad g =>
(String -> String -> Bool)
-> f g
splitDirectories ::
Monad g =>
([FilePath] -> Bool)
-> f g
hasTrailingPathSeparator ::
Monad g =>
f g
hasTrailingPathSeparator =
(.!.) notHasTrailingPathSeparator
notHasTrailingPathSeparator::
Monad g =>
f g
notHasTrailingPathSeparator =
(.!.) hasTrailingPathSeparator
fileName ::
Monad g =>
(FilePath -> Bool)
-> f g
baseName ::
Monad g =>
(FilePath -> Bool)
-> f g
normalise ::
Monad g =>
(FilePath -> Bool)
-> f g
makeValid ::
Monad g =>
(FilePath -> Bool)
-> f g
isRelative ::
Monad g =>
f g
isRelative =
(.!.) isNotRelative
isNotRelative ::
Monad g =>
f g
isNotRelative =
(.!.) isRelative
isAbsolute ::
Monad g =>
f g
isAbsolute =
(.!.) isNotAbsolute
isNotAbsolute ::
Monad g =>
f g
isNotAbsolute =
(.!.) isAbsolute
isValid ::
Monad g =>
f g
isValid =
(.!.) isNotValid
isNotValid ::
Monad g =>
f g
isNotValid =
(.!.) isValid
instance FilePathPredicate RecursePredicateT where
always =
recursePredicateT . const . return $ True
never =
recursePredicateT . const . return $ False
f .&&. g =
recursePredicateT $ \p -> do r <- runRecursePredicateT f p
if r
then
runRecursePredicateT g p
else
return False
f .||. g =
recursePredicateT $ \p -> do r <- runRecursePredicateT f p
if r
then
return True
else
runRecursePredicateT g p
(.!.) f =
recursePredicateT $ liftM not . runRecursePredicateT f
extension f =
recursePredicateT $ return . f . P.takeExtension
directory f =
recursePredicateT $ return . f . P.takeDirectory
hasExtension =
recursePredicateT $ return . P.hasExtension
splitExtension f =
recursePredicateT $ return . uncurry f . P.splitExtension
splitDirectories f =
recursePredicateT $ return . f . P.splitDirectories
hasTrailingPathSeparator =
recursePredicateT $ return . P.hasTrailingPathSeparator
fileName f =
recursePredicateT $ return . f . P.takeFileName
baseName f =
recursePredicateT $ return . f . P.takeBaseName
normalise f =
recursePredicateT $ return . f . P.normalise
makeValid f =
recursePredicateT $ return . f . P.makeValid
isRelative =
recursePredicateT $ return . P.isRelative
isAbsolute =
recursePredicateT $ return . P.isAbsolute
isValid =
recursePredicateT $ return . P.isValid
instance FilePathPredicate FilterPredicateT where
always =
filterPredicateT . const . const . return $ True
never =
filterPredicateT . const . const . return $ False
f .&&. g =
filterPredicateT $ \p k -> do r <- runFilterPredicateT f p k
if r
then
runFilterPredicateT g p k
else
return False
f .||. g =
filterPredicateT $ \p k -> do r <- runFilterPredicateT f p k
if r
then
return True
else
runFilterPredicateT g p k
(.!.) f =
filterPredicateT $ \p -> liftM not . runFilterPredicateT f p
extension f =
filterPredicateT $ const . return . f . P.takeExtension
directory f =
filterPredicateT $ const . return . f . P.takeDirectory
hasExtension =
filterPredicateT $ const . return . P.hasExtension
splitExtension f =
filterPredicateT $ const . return . uncurry f . P.splitExtension
splitDirectories f =
filterPredicateT $ const . return . f . P.splitDirectories
hasTrailingPathSeparator =
filterPredicateT $ const . return . P.hasTrailingPathSeparator
fileName f =
filterPredicateT $ const . return . f . P.takeFileName
baseName f =
filterPredicateT $ const . return . f . P.takeBaseName
normalise f =
filterPredicateT $ const . return . f . P.normalise
makeValid f =
filterPredicateT $ const . return . f . P.makeValid
isRelative =
filterPredicateT $ const . return . P.isRelative
isAbsolute =
filterPredicateT $ const . return . P.isAbsolute
isValid =
filterPredicateT $ const . return . P.isValid