System.Posix.FilePath

The equivalent of System.FilePath on raw (byte string) file paths.

Not all functions of System.FilePath are implemented yet. Feel free to contribute!

Documentation

pathSeparator :: Word8

Path separator character

isPathSeparator :: Word8 -> Bool

Check if a character is the path separator

\n ->  (_chr n == '/') == isPathSeparator n

searchPathSeparator :: Word8

Search path separator

isSearchPathSeparator :: Word8 -> Bool

Check if a character is the search path separator

\n -> (_chr n == ':') == isSearchPathSeparator n

extSeparator :: Word8

File extension separator

isExtSeparator :: Word8 -> Bool

Check if a character is the file extension separator

\n -> (_chr n == '.') == isExtSeparator n

splitExtension :: RawFilePath -> (RawFilePath, ByteString)

Split a RawFilePath into a path+filename and extension

>>> splitExtension "file.exe"
("file",".exe")

>>> splitExtension "file"
("file","")

>>> splitExtension "/path/file.tar.gz"
("/path/file.tar",".gz")

\path -> uncurry (BS.append) (splitExtension path) == path

takeExtension :: RawFilePath -> ByteString

Get the final extension from a RawFilePath

>>> takeExtension "file.exe"
".exe"

>>> takeExtension "file"
""

>>> takeExtension "/path/file.tar.gz"
".gz"

replaceExtension :: RawFilePath -> ByteString -> RawFilePath

Change a file's extension

\path -> let ext = takeExtension path in replaceExtension path ext == path

dropExtension :: RawFilePath -> RawFilePath

Drop the final extension from a RawFilePath

>>> dropExtension "file.exe"
"file"

>>> dropExtension "file"
"file"

>>> dropExtension "/path/file.tar.gz"
"/path/file.tar"

addExtension :: RawFilePath -> ByteString -> RawFilePath

Add an extension to a RawFilePath

>>> addExtension "file" ".exe"
"file.exe"

>>> addExtension "file.tar" ".gz"
"file.tar.gz"

>>> addExtension "/path/" ".ext"
"/path/.ext"

hasExtension :: RawFilePath -> Bool

Check if a RawFilePath has an extension

>>> hasExtension "file"
False

>>> hasExtension "file.tar"
True

>>> hasExtension "/path.part1/"
False

(<.>) :: RawFilePath -> ByteString -> RawFilePath

Operator version of addExtension

splitExtensions :: RawFilePath -> (RawFilePath, ByteString)

Split a RawFilePath on the first extension

>>> splitExtensions "/path/file.tar.gz"
("/path/file",".tar.gz")

\path -> uncurry addExtension (splitExtensions path) == path

dropExtensions :: RawFilePath -> RawFilePath

Remove all extensions from a RawFilePath

>>> dropExtensions "/path/file.tar.gz"
"/path/file"

takeExtensions :: RawFilePath -> ByteString

Take all extensions from a RawFilePath

>>> takeExtensions "/path/file.tar.gz"
".tar.gz"

splitFileName :: RawFilePath -> (RawFilePath, RawFilePath)

Split a RawFilePath into (path,file). combine is the inverse

>>> splitFileName "path/file.txt"
("path/","file.txt")

>>> splitFileName "path/"
("path/","")

>>> splitFileName "file.txt"
("./","file.txt")

\path -> uncurry combine (splitFileName path) == path || fst (splitFileName path) == "./"

takeFileName :: RawFilePath -> RawFilePath

Get the file name

>>> takeFileName "path/file.txt"
"file.txt"

>>> takeFileName "path/"
""

replaceFileName :: RawFilePath -> ByteString -> RawFilePath

Change the file name

\path -> replaceFileName path (takeFileName path) == path

dropFileName :: RawFilePath -> RawFilePath

Drop the file name

>>> dropFileName "path/file.txt"
"path/"

>>> dropFileName "file.txt"
"./"

takeBaseName :: RawFilePath -> ByteString

Get the file name, without a trailing extension

>>> takeBaseName "path/file.tar.gz"
"file.tar"

>>> takeBaseName ""
""

replaceBaseName :: RawFilePath -> ByteString -> RawFilePath

Change the base name

>>> replaceBaseName "path/file.tar.gz" "bob"
"path/bob.gz"

\path -> replaceBaseName path (takeBaseName path) == path

takeDirectory :: RawFilePath -> RawFilePath

Get the directory, moving up one level if it's already a directory

>>> takeDirectory "path/file.txt"
"path"

>>> takeDirectory "file"
"."

>>> takeDirectory "/path/to/"
"/path/to"

>>> takeDirectory "/path/to"
"/path"

replaceDirectory :: RawFilePath -> ByteString -> RawFilePath

Change the directory component of a RawFilePath

\path -> replaceDirectory path (takeDirectory path) `_equalFilePath` path || takeDirectory path == "."

combine :: RawFilePath -> RawFilePath -> RawFilePath

Join two paths together

>>> combine "/" "file"
"/file"
>>> combine "/path/to" "file"
"/path/to/file"
>>> combine "file" "/absolute/path"
"/absolute/path"

(</>) :: RawFilePath -> RawFilePath -> RawFilePath

Operator version of combine

splitPath :: RawFilePath -> [RawFilePath]

Split a path into a list of components:

>>> splitPath "/path/to/file.txt"
["/","path/","to/","file.txt"]

\path -> BS.concat (splitPath path) == path

joinPath :: [RawFilePath] -> RawFilePath

Join a split path back together

\path -> joinPath (splitPath path) == path

>>> joinPath ["path","to","file.txt"]
"path/to/file.txt"

splitDirectories :: RawFilePath -> [RawFilePath]

Like splitPath, but without trailing slashes

>>> splitDirectories "/path/to/file.txt"
["/","path","to","file.txt"]
>>> splitDirectories ""
[]

hasTrailingPathSeparator :: RawFilePath -> Bool

Check if the last character of a RawFilePath is /, unless it's the root.

>>> hasTrailingPathSeparator "/path/"
True
>>> hasTrailingPathSeparator "/"
False

addTrailingPathSeparator :: RawFilePath -> RawFilePath

Add a trailing path separator.

>>> addTrailingPathSeparator "/path"
"/path/"

>>> addTrailingPathSeparator "/path/"
"/path/"

dropTrailingPathSeparator :: RawFilePath -> RawFilePath

Remove a trailing path separator

>>> dropTrailingPathSeparator "/path/"
"/path"

>>> dropTrailingPathSeparator "/"
"/"

isRelative :: RawFilePath -> Bool

Check if a path is relative

\path -> isRelative path /= isAbsolute path

isAbsolute :: RawFilePath -> Bool

Check if a path is absolute

>>> isAbsolute "/path"
True
>>> isAbsolute "path"
False
>>> isAbsolute ""
False

module System.Posix.ByteString.FilePath