System.Posix.FilePath

posix-paths-0.3.0.0: POSIX filepath/directory functionality

Safe Haskell | Safe-Inferred
Language | Haskell2010

System.Posix.FilePath

Description

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

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

Synopsis

- pathSeparator :: Word8
- isPathSeparator :: Word8 -> Bool
- searchPathSeparator :: Word8
- isSearchPathSeparator :: Word8 -> Bool
- extSeparator :: Word8
- isExtSeparator :: Word8 -> Bool
- splitExtension :: RawFilePath -> (RawFilePath, ByteString)
- takeExtension :: RawFilePath -> ByteString
- replaceExtension :: RawFilePath -> ByteString -> RawFilePath
- dropExtension :: RawFilePath -> RawFilePath
- addExtension :: RawFilePath -> ByteString -> RawFilePath
- hasExtension :: RawFilePath -> Bool
- (<.>) :: RawFilePath -> ByteString -> RawFilePath
- splitExtensions :: RawFilePath -> (RawFilePath, ByteString)
- dropExtensions :: RawFilePath -> RawFilePath
- takeExtensions :: RawFilePath -> ByteString
- splitFileName :: RawFilePath -> (RawFilePath, RawFilePath)
- takeFileName :: RawFilePath -> RawFilePath
- replaceFileName :: RawFilePath -> ByteString -> RawFilePath
- dropFileName :: RawFilePath -> RawFilePath
- takeBaseName :: RawFilePath -> ByteString
- replaceBaseName :: RawFilePath -> ByteString -> RawFilePath
- takeDirectory :: RawFilePath -> RawFilePath
- replaceDirectory :: RawFilePath -> ByteString -> RawFilePath
- combine :: RawFilePath -> RawFilePath -> RawFilePath
- (</>) :: RawFilePath -> RawFilePath -> RawFilePath
- splitPath :: RawFilePath -> [RawFilePath]
- joinPath :: [RawFilePath] -> RawFilePath
- splitDirectories :: RawFilePath -> [RawFilePath]
- hasTrailingPathSeparator :: RawFilePath -> Bool
- addTrailingPathSeparator :: RawFilePath -> RawFilePath
- dropTrailingPathSeparator :: RawFilePath -> RawFilePath
- isRelative :: RawFilePath -> Bool
- isAbsolute :: RawFilePath -> Bool
- module System.Posix.ByteString.FilePath

# 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