Darcs.Util.Path

Documentation

encodeWhite :: FilePath -> String

encodeWhite translates whitespace in filenames to a darcs-specific format (numerical representation according to ord surrounded by backslashes). Note that backslashes are also escaped since they are used in the encoding.

encodeWhite "hello there" == "hello\32\there"
encodeWhite "hello\there" == "hello\92\there"

decodeWhite :: String -> FilePath

decodeWhite interprets the Darcs-specific "encoded" filenames produced by encodeWhite

decodeWhite "hello\32\there"  == "hello there"
decodeWhite "hello\92\there"  == "hello\there"
decodeWhite "hello\there"   == error "malformed filename"

encodeWhiteName :: Name -> ByteString

decodeWhiteName :: ByteString -> Name

AbsolutePath

data AbsolutePath

Instances

Eq AbsolutePath

Defined in Darcs.Util.Path

Methods

(==) :: AbsolutePath -> AbsolutePath -> Bool

(/=) :: AbsolutePath -> AbsolutePath -> Bool

Ord AbsolutePath

Defined in Darcs.Util.Path

Methods

compare :: AbsolutePath -> AbsolutePath -> Ordering

(<) :: AbsolutePath -> AbsolutePath -> Bool

(<=) :: AbsolutePath -> AbsolutePath -> Bool

(>) :: AbsolutePath -> AbsolutePath -> Bool

(>=) :: AbsolutePath -> AbsolutePath -> Bool

max :: AbsolutePath -> AbsolutePath -> AbsolutePath

min :: AbsolutePath -> AbsolutePath -> AbsolutePath

Show AbsolutePath

Defined in Darcs.Util.Path

Methods

showsPrec :: Int -> AbsolutePath -> ShowS

show :: AbsolutePath -> String

showList :: [AbsolutePath] -> ShowS

FilePathLike AbsolutePath

Defined in Darcs.Util.Path

Methods

toFilePath :: AbsolutePath -> FilePath

FilePathOrURL AbsolutePath

Defined in Darcs.Util.Path

Methods

toPath :: AbsolutePath -> String

makeAbsolute :: AbsolutePath -> FilePath -> AbsolutePath

Take an absolute path and a string representing a (possibly relative) path and combine them into an absolute path. If the second argument is already absolute, then the first argument gets ignored. This function also takes care that the result is converted to Posix convention and normalized. Also, parent directories ("..") at the front of the string argument get canceled out against trailing directory parts of the absolute path argument.

Regarding the last point, someone more familiar with how these functions are used should verify that this is indeed necessary or at least useful.

ioAbsolute :: FilePath -> IO AbsolutePath

Interpret a possibly relative path wrt the current working directory.

AbsolutePathOrStd

data AbsolutePathOrStd

This is for situations where a string (e.g. a command line argument) may take the value "-" to mean stdin or stdout (which one depends on context) instead of a normal file path.

Instances

Eq AbsolutePathOrStd

Defined in Darcs.Util.Path

Methods

(==) :: AbsolutePathOrStd -> AbsolutePathOrStd -> Bool

(/=) :: AbsolutePathOrStd -> AbsolutePathOrStd -> Bool

Ord AbsolutePathOrStd

Defined in Darcs.Util.Path

Methods

compare :: AbsolutePathOrStd -> AbsolutePathOrStd -> Ordering

(<) :: AbsolutePathOrStd -> AbsolutePathOrStd -> Bool

(<=) :: AbsolutePathOrStd -> AbsolutePathOrStd -> Bool

(>) :: AbsolutePathOrStd -> AbsolutePathOrStd -> Bool

(>=) :: AbsolutePathOrStd -> AbsolutePathOrStd -> Bool

max :: AbsolutePathOrStd -> AbsolutePathOrStd -> AbsolutePathOrStd

min :: AbsolutePathOrStd -> AbsolutePathOrStd -> AbsolutePathOrStd

Show AbsolutePathOrStd

Defined in Darcs.Util.Path

Methods

showsPrec :: Int -> AbsolutePathOrStd -> ShowS

show :: AbsolutePathOrStd -> String

showList :: [AbsolutePathOrStd] -> ShowS

makeAbsoluteOrStd :: AbsolutePath -> String -> AbsolutePathOrStd

ioAbsoluteOrStd :: String -> IO AbsolutePathOrStd

useAbsoluteOrStd :: (AbsolutePath -> a) -> a -> AbsolutePathOrStd -> a

Execute either the first or the second argument action, depending on whether the given path is an AbsolutePath or stdin/stdout.

stdOut :: AbsolutePathOrStd

AbsoluteOrRemotePath

data AbsoluteOrRemotePath

Instances

Eq AbsoluteOrRemotePath

Defined in Darcs.Util.Path

Methods

(==) :: AbsoluteOrRemotePath -> AbsoluteOrRemotePath -> Bool

(/=) :: AbsoluteOrRemotePath -> AbsoluteOrRemotePath -> Bool

Ord AbsoluteOrRemotePath

Defined in Darcs.Util.Path

Methods

compare :: AbsoluteOrRemotePath -> AbsoluteOrRemotePath -> Ordering

(<) :: AbsoluteOrRemotePath -> AbsoluteOrRemotePath -> Bool

(<=) :: AbsoluteOrRemotePath -> AbsoluteOrRemotePath -> Bool

(>) :: AbsoluteOrRemotePath -> AbsoluteOrRemotePath -> Bool

(>=) :: AbsoluteOrRemotePath -> AbsoluteOrRemotePath -> Bool

max :: AbsoluteOrRemotePath -> AbsoluteOrRemotePath -> AbsoluteOrRemotePath

min :: AbsoluteOrRemotePath -> AbsoluteOrRemotePath -> AbsoluteOrRemotePath

Show AbsoluteOrRemotePath

Defined in Darcs.Util.Path

Methods

showsPrec :: Int -> AbsoluteOrRemotePath -> ShowS

show :: AbsoluteOrRemotePath -> String

showList :: [AbsoluteOrRemotePath] -> ShowS

FilePathOrURL AbsoluteOrRemotePath

Defined in Darcs.Util.Path

Methods

toPath :: AbsoluteOrRemotePath -> String

ioAbsoluteOrRemote :: String -> IO AbsoluteOrRemotePath

isRemote :: AbsoluteOrRemotePath -> Bool

SubPath

data SubPath

Paths which are relative to the local darcs repository and normalized. Note: These are understood not to have the dot in front.

Instances

Eq SubPath

Defined in Darcs.Util.Path

Methods

(==) :: SubPath -> SubPath -> Bool

(/=) :: SubPath -> SubPath -> Bool

Ord SubPath

Defined in Darcs.Util.Path

Methods

compare :: SubPath -> SubPath -> Ordering

(<) :: SubPath -> SubPath -> Bool

(<=) :: SubPath -> SubPath -> Bool

(>) :: SubPath -> SubPath -> Bool

(>=) :: SubPath -> SubPath -> Bool

max :: SubPath -> SubPath -> SubPath

min :: SubPath -> SubPath -> SubPath

Show SubPath

Defined in Darcs.Util.Path

Methods

showsPrec :: Int -> SubPath -> ShowS

show :: SubPath -> String

showList :: [SubPath] -> ShowS

FilePathLike SubPath

Defined in Darcs.Util.Path

Methods

toFilePath :: SubPath -> FilePath

FilePathOrURL SubPath

Defined in Darcs.Util.Path

Methods

toPath :: SubPath -> String

makeSubPathOf :: AbsolutePath -> AbsolutePath -> Maybe SubPath

Make the second path relative to the first, if possible

simpleSubPath :: FilePath -> Maybe SubPath

floatSubPath :: SubPath -> AnchoredPath

Transform a SubPath into an AnchoredPath.

Miscellaneous

class FilePathOrURL a where

Methods

toPath :: a -> String

Instances

FilePathOrURL AbsoluteOrRemotePath

Defined in Darcs.Util.Path

Methods

toPath :: AbsoluteOrRemotePath -> String

FilePathOrURL AbsolutePath

Defined in Darcs.Util.Path

Methods

toPath :: AbsolutePath -> String

FilePathOrURL SubPath

Defined in Darcs.Util.Path

Methods

toPath :: SubPath -> String

CharLike c => FilePathOrURL [c]

Defined in Darcs.Util.Path

Methods

toPath :: [c] -> String

class FilePathOrURL a => FilePathLike a where

Methods

toFilePath :: a -> FilePath

Instances

FilePathLike AbsolutePath

Defined in Darcs.Util.Path

Methods

toFilePath :: AbsolutePath -> FilePath

FilePathLike SubPath

Defined in Darcs.Util.Path

Methods

toFilePath :: SubPath -> FilePath

CharLike c => FilePathLike [c]

Defined in Darcs.Util.Path

Methods

toFilePath :: [c] -> FilePath

getCurrentDirectory :: IO AbsolutePath

setCurrentDirectory :: FilePathLike p => p -> IO ()

getUniquePathName :: Bool -> (FilePath -> String) -> (Int -> FilePath) -> IO FilePath

Iteratively tries find first non-existing path generated by buildName, it feeds to buildName the number starting with -1. When it generates non-existing path and it isn't first, it displays the message created with buildMsg. Usually used for generation of the name like path_number when path already exist (e.g. darcs.net_0).

doesPathExist :: FilePath -> IO Bool

Check for malicious paths

isMaliciousSubPath :: String -> Bool

What is a malicious path?

A spoofed path is a malicious path.

1. Darcs only creates explicitly relative paths (beginning with "./"), so any not explicitly relative path is surely spoofed.
2. Darcs normalizes paths so they never contain "/../", so paths with "/../" are surely spoofed.

A path to a darcs repository's meta data can modify "trusted" patches or change safety defaults in that repository, so we check for paths containing "/_darcs/" which is the entry to darcs meta data.

To do?

• How about get repositories?
• Would it be worth adding a --semi-safe-paths option for allowing changes to certain preference files (_darcs/prefs/) in sub repositories'?

TODO: Properly review the way we handle paths on Windows - it's not enough to just use the OS native concept of path separator. Windows often accepts both path separators, and repositories always use the UNIX separator anyway.

Tree filtering.

filterPaths :: [AnchoredPath] -> AnchoredPath -> t -> Bool

Construct a filter from a list of AnchoredPaths, that will accept any path that is either a parent or a child of any of the listed paths, and discard everything else.

AnchoredPaths: relative paths within a Tree. All paths are

data Name

Instances

Eq Name

Defined in Darcs.Util.Path

Methods

(==) :: Name -> Name -> Bool

(/=) :: Name -> Name -> Bool

Ord Name

Defined in Darcs.Util.Path

Methods

compare :: Name -> Name -> Ordering

(<) :: Name -> Name -> Bool

(<=) :: Name -> Name -> Bool

(>) :: Name -> Name -> Bool

(>=) :: Name -> Name -> Bool

max :: Name -> Name -> Name

min :: Name -> Name -> Name

Show Name

Defined in Darcs.Util.Path

Methods

showsPrec :: Int -> Name -> ShowS

show :: Name -> String

showList :: [Name] -> ShowS

Binary Name

Defined in Darcs.Util.Path

Methods

put :: Name -> Put

get :: Get Name

putList :: [Name] -> Put

name2fp :: Name -> FilePath

makeName :: String -> Either String Name

Make a Name from a String. If the input String is invalid, that is, "", ".", "..", or contains a /, return Left with an error message.

rawMakeName :: ByteString -> Either String Name

Make a Name from a ByteString.

eqAnycase :: Name -> Name -> Bool

newtype AnchoredPath

This is a type of "sane" file paths. These are always canonic in the sense that there are no stray slashes, no ".." components and similar. They are usually used to refer to a location within a Tree, but a relative filesystem path works just as well. These are either constructed from individual name components (using "appendPath", "catPaths" and "makeName"), or converted from a FilePath ("floatPath" -- but take care when doing that).

Constructors

AnchoredPath [Name]

Instances

Eq AnchoredPath

Defined in Darcs.Util.Path

Methods

(==) :: AnchoredPath -> AnchoredPath -> Bool

(/=) :: AnchoredPath -> AnchoredPath -> Bool

Ord AnchoredPath

Defined in Darcs.Util.Path

Methods

compare :: AnchoredPath -> AnchoredPath -> Ordering

(<) :: AnchoredPath -> AnchoredPath -> Bool

(<=) :: AnchoredPath -> AnchoredPath -> Bool

(>) :: AnchoredPath -> AnchoredPath -> Bool

(>=) :: AnchoredPath -> AnchoredPath -> Bool

max :: AnchoredPath -> AnchoredPath -> AnchoredPath

min :: AnchoredPath -> AnchoredPath -> AnchoredPath

Show AnchoredPath

Defined in Darcs.Util.Path

Methods

showsPrec :: Int -> AnchoredPath -> ShowS

show :: AnchoredPath -> String

showList :: [AnchoredPath] -> ShowS

Binary AnchoredPath

Defined in Darcs.Util.Path

Methods

put :: AnchoredPath -> Put

get :: Get AnchoredPath

putList :: [AnchoredPath] -> Put

Monad m => ApplyMonad Tree (TreeMonad m)

Defined in Darcs.Patch.ApplyMonad

Associated Types

type ApplyMonadBase (TreeMonad m) :: Type -> Type

Methods

nestedApply :: TreeMonad m x -> Tree (ApplyMonadBase (TreeMonad m)) -> TreeMonad m (x, Tree (ApplyMonadBase (TreeMonad m)))

liftApply :: (Tree (ApplyMonadBase (TreeMonad m)) -> ApplyMonadBase (TreeMonad m) x) -> Tree (ApplyMonadBase (TreeMonad m)) -> TreeMonad m (x, Tree (ApplyMonadBase (TreeMonad m)))

getApplyState :: TreeMonad m (Tree (ApplyMonadBase (TreeMonad m)))

Monad m => TreeRW (TreeMonad m)

Defined in Darcs.Util.Tree.Monad

Methods

writeFile :: AnchoredPath -> ByteString -> TreeMonad m ()

createDirectory :: AnchoredPath -> TreeMonad m ()

unlink :: AnchoredPath -> TreeMonad m ()

rename :: AnchoredPath -> AnchoredPath -> TreeMonad m ()

copy :: AnchoredPath -> AnchoredPath -> TreeMonad m ()

Monad m => TreeRO (TreeMonad m)

Defined in Darcs.Util.Tree.Monad

Methods

currentDirectory :: TreeMonad m AnchoredPath

withDirectory :: AnchoredPath -> TreeMonad m a -> TreeMonad m a

expandTo :: AnchoredPath -> TreeMonad m AnchoredPath

readFile :: AnchoredPath -> TreeMonad m ByteString

exists :: AnchoredPath -> TreeMonad m Bool

directoryExists :: AnchoredPath -> TreeMonad m Bool

fileExists :: AnchoredPath -> TreeMonad m Bool

Monad m => MonadProgress (TreeMonad m)

Defined in Darcs.Patch.MonadProgress

Methods

runProgressActions :: String -> [ProgressAction (TreeMonad m) ()] -> TreeMonad m ()

Monad m => ApplyMonadTree (TreeMonad m)

Defined in Darcs.Patch.ApplyMonad

Methods

mDoesDirectoryExist :: AnchoredPath -> TreeMonad m Bool

mDoesFileExist :: AnchoredPath -> TreeMonad m Bool

mReadFilePS :: AnchoredPath -> TreeMonad m ByteString

mCreateDirectory :: AnchoredPath -> TreeMonad m ()

mRemoveDirectory :: AnchoredPath -> TreeMonad m ()

mCreateFile :: AnchoredPath -> TreeMonad m ()

mRemoveFile :: AnchoredPath -> TreeMonad m ()

mRename :: AnchoredPath -> AnchoredPath -> TreeMonad m ()

mModifyFilePS :: AnchoredPath -> (ByteString -> TreeMonad m ByteString) -> TreeMonad m ()

mChangePref :: String -> String -> String -> TreeMonad m ()

type ApplyMonadBase (TreeMonad m)

Defined in Darcs.Patch.ApplyMonad

type ApplyMonadBase (TreeMonad m) = m

anchoredRoot :: AnchoredPath

appendPath :: AnchoredPath -> Name -> AnchoredPath

Append an element to the end of a path.

anchorPath :: FilePath -> AnchoredPath -> FilePath

Take a "root" directory and an anchored path and produce a full FilePath. Moreover, you can use anchorPath "" to get a relative FilePath.

isPrefix :: AnchoredPath -> AnchoredPath -> Bool

Check whether a path is a prefix of another path.

breakOnDir :: AnchoredPath -> Either Name (Name, AnchoredPath)

If the patch is under a directory, split into Right of the first component (which must be a directory name) and the rest of teh path. Otherwise return Left of the single component. This function is *undefined* on the root path (which has no components).

movedirfilename :: AnchoredPath -> AnchoredPath -> AnchoredPath -> AnchoredPath

The effect of renaming on paths. The first argument is the old path, the second is the new path, and the third is the possibly affected path we are interested in.

parent :: AnchoredPath -> Maybe AnchoredPath

Get parent (path) of a given path. foobarbaz -> foo/bar

parents :: AnchoredPath -> [AnchoredPath]

List all parents of a given path. foobarbaz -> [.,foo, foo/bar]

replaceParent :: AnchoredPath -> AnchoredPath -> Maybe AnchoredPath

Replace the second arg's parent with the first arg.

catPaths :: AnchoredPath -> AnchoredPath -> AnchoredPath

Catenate two paths together. Not very safe, but sometimes useful (e.g. when you are representing paths relative to a different point than a Tree root).

flatten :: AnchoredPath -> ByteString

inDarcsdir :: AnchoredPath -> Bool

Is the given path in (or equal to) the _darcs metadata directory?

displayPath :: AnchoredPath -> FilePath

For displaying paths to the user. It should never be used for on-disk patch storage. This adds the "./" for consistency with how repo paths are displayed by showPatch and friends, except for the root path which is displayed as plain ".".

realPath :: AnchoredPath -> FilePath

Interpret an AnchoredPath as relative the current working directory. Intended for IO operations in the file system. Use with care!

isRoot :: AnchoredPath -> Bool

darcsdirName :: Name

Unsafe AnchoredPath functions.

floatPath :: FilePath -> AnchoredPath

Take a relative FilePath and turn it into an AnchoredPath. This is a partial function. Basically, by using floatPath, you are testifying that the argument is a path relative to some common root -- i.e. the root of the associated Tree object. In particular, the input path may not contain any ocurrences of "." or ".." after normalising. You should sanitize any FilePaths before you declare them "good" by converting into AnchoredPath (using this function), especially if the FilePath come from any external source (command line, file, environment, network, etc)