module System.Path.Posix (
Path,
AbsFile, RelFile, AbsDir, RelDir,
AbsPath, RelPath, FilePath, DirPath,
AbsOrRelFile, AbsOrRelDir, AbsFileOrDir, RelFileOrDir,
AbsOrRelPath, FileOrDirPath, AbsOrRelFileOrDir,
asPath,
asRelFile, asRelDir, asAbsFile, asAbsDir,
asRelPath, asAbsPath, asFilePath, asDirPath,
path, maybePath,
relFile, relDir, absFile, absDir,
relPath, absPath, filePath, dirPath,
rootDir, currentDir, emptyFile,
toString,
isAbsoluteString, isRelativeString, equalFilePath,
pathSeparator, pathSeparators, isPathSeparator,
Core.extSeparator, Core.isExtSeparator,
Core.searchPathSeparator, Core.isSearchPathSeparator,
addTrailingPathSeparator, dropTrailingPathSeparator,
hasTrailingPathSeparator,
testAll,
) where
import qualified System.Path.RegularExpression as RegEx
import qualified System.Path.Internal as Core
import System.Path.Internal (
Abs, Rel, AbsOrRel, File, Dir, FileOrDir,
AbsRelClass, FileDirClass,
AbsOrRelClass, FileOrDirClass,
)
import Data.Tagged (Tagged(Tagged), untag)
import Prelude hiding (FilePath)
data Posix = Posix
_osDummy :: Posix
_osDummy = Posix
type Path = Core.Path Posix
type AbsFile = Path Abs File
type RelFile = Path Rel File
type AbsDir = Path Abs Dir
type RelDir = Path Rel Dir
type AbsOrRelFile = Path AbsOrRel File
type AbsOrRelDir = Path AbsOrRel Dir
type AbsFileOrDir = Path Abs FileOrDir
type RelFileOrDir = Path Rel FileOrDir
type AbsOrRelFileOrDir = Path AbsOrRel FileOrDir
type AbsPath fd = Path Abs fd
type RelPath fd = Path Rel fd
type FilePath ar = Path ar File
type DirPath ar = Path ar Dir
type AbsOrRelPath fd = Path AbsOrRel fd
type FileOrDirPath ar = Path ar FileOrDir
asPath :: (AbsRelClass ar, FileDirClass fd) => String -> Path ar fd
asPath = Core.asPath
asRelFile :: String -> RelFile
asRelFile = Core.asRelFile
asRelDir :: String -> RelDir
asRelDir = Core.asRelDir
asAbsFile :: String -> AbsFile
asAbsFile = Core.asAbsFile
asAbsDir :: String -> AbsDir
asAbsDir = Core.asAbsDir
asRelPath :: (FileDirClass fd) => String -> RelPath fd
asRelPath = Core.asRelPath
asAbsPath :: (FileDirClass fd) => String -> AbsPath fd
asAbsPath = Core.asAbsPath
asFilePath :: (AbsRelClass ar) => String -> FilePath ar
asFilePath = Core.asFilePath
asDirPath :: (AbsRelClass ar) => String -> DirPath ar
asDirPath = Core.asDirPath
maybePath ::
(AbsOrRelClass ar, FileOrDirClass fd) => String -> Maybe (Path ar fd)
maybePath = Core.maybePath
path :: (AbsOrRelClass ar, FileOrDirClass fd) => String -> Path ar fd
path = Core.path
relFile :: String -> RelFile
relFile = Core.relFile
relDir :: String -> RelDir
relDir = Core.relDir
absFile :: String -> AbsFile
absFile = Core.absFile
absDir :: String -> AbsDir
absDir = Core.absDir
relPath :: (FileOrDirClass fd) => String -> RelPath fd
relPath = Core.relPath
absPath :: (FileOrDirClass fd) => String -> AbsPath fd
absPath = Core.absPath
filePath :: (AbsOrRelClass ar) => String -> FilePath ar
filePath = Core.filePath
dirPath :: (AbsOrRelClass ar) => String -> DirPath ar
dirPath = Core.dirPath
rootDir :: AbsDir
rootDir = Core.rootDir
currentDir :: RelDir
currentDir = Core.currentDir
emptyFile :: RelFile
emptyFile = Core.emptyFile
toString :: (AbsOrRelClass ar, FileOrDirClass fd) => Path ar fd -> String
toString = Core.toString
instance Core.System Posix where
pathSeparator = Tagged pathSeparator
splitAbsolute = Tagged $ RegEx.run $ RegEx.single isPathSeparator
canonicalize = Tagged id
splitDrive = Tagged $ return ""
genDrive = Tagged $ return ""
withOS :: Tagged Posix a -> a
withOS = untag
equalFilePath :: String -> String -> Bool
equalFilePath = withOS Core.equalFilePath
isAbsoluteString :: String -> Bool
isAbsoluteString = withOS Core.isAbsoluteString
isRelativeString :: String -> Bool
isRelativeString = withOS Core.isRelativeString
pathSeparator :: Char
pathSeparator = '/'
pathSeparators :: [Char]
pathSeparators = withOS Core.pathSeparators
isPathSeparator :: Char -> Bool
isPathSeparator = withOS Core.isPathSeparator
addTrailingPathSeparator :: String -> String
addTrailingPathSeparator = (++[pathSeparator])
dropTrailingPathSeparator :: String -> String
dropTrailingPathSeparator = init
hasTrailingPathSeparator :: String -> Bool
hasTrailingPathSeparator = isPathSeparator . last
testAll :: [(String, IO ())]
testAll = Core.testAll Posix