packages feed

darcs 2.5 → 2.5.1

raw patch · 69 files changed

+764/−302 lines, 69 filesdep ~HTTPdep ~containersdep ~directorynew-uploaderbinary-addedPVP: major bump suggested

API removals or changes: PVP suggests a major version bump

Dependency ranges changed: HTTP, containers, directory, filepath, mtl, network, text

API changes (from Hackage documentation)

- Darcs.Hopefully: instance (Apply p) => Apply (PatchInfoAnd p)
- Darcs.Hopefully: instance (Commute p) => Commute (PatchInfoAnd p)
- Darcs.Hopefully: instance (Conflict p) => Conflict (PatchInfoAnd p)
- Darcs.Hopefully: instance (Effect p) => Effect (PatchInfoAnd p)
- Darcs.Hopefully: instance (Invert p) => Invert (PatchInfoAnd p)
- Darcs.Hopefully: instance (MyEq p) => MyEq (PatchInfoAnd p)
- Darcs.Hopefully: instance (ReadPatch p) => ReadPatch (PatchInfoAnd p)
- Darcs.Hopefully: instance (RepoPatch p) => Patchy (PatchInfoAnd p)
- Darcs.Patch: instance (RepoPatchBase p) => RepoPatch (FL p)
- Darcs.Patch.Apply: instance (Apply p) => Apply (Named p)
- Darcs.Patch.Choices: instance (Commute p) => Commute (PatchChoice p)
- Darcs.Patch.Choices: instance (Commute p) => Commute (TaggedPatch p)
- Darcs.Patch.Choices: instance (Invert p) => Invert (TaggedPatch p)
- Darcs.Patch.Choices: instance (MyEq p) => MyEq (PatchChoice p)
- Darcs.Patch.Choices: instance (MyEq p) => MyEq (TaggedPatch p)
- Darcs.Patch.Commute: instance (Commute p) => Commute (Named p)
- Darcs.Patch.Commute: instance (Conflict p) => Conflict (Named p)
- Darcs.Patch.Commute: instance (Invert p) => Invert (Named p)
- Darcs.Patch.Commute: instance (MyEq p) => MyEq (Named p)
- Darcs.Patch.Core: instance (Effect p) => Effect (Named p)
- Darcs.Patch.Non: instance (Show2 p) => Show (Non p)
- Darcs.Patch.Non: instance (Show2 p) => Show1 (Non p)
- Darcs.Patch.Patchy: instance (Apply p) => Apply (FL p)
- Darcs.Patch.Patchy: instance (Apply p) => Apply (RL p)
- Darcs.Patch.Patchy: instance (Commute p) => Commute (FL p)
- Darcs.Patch.Patchy: instance (Commute p) => Commute (RL p)
- Darcs.Patch.Patchy: instance (ReadPatch p) => ReadPatch (FL p)
- Darcs.Patch.Patchy: instance (ReadPatch p) => ReadPatch (RL p)
- Darcs.Patch.Prim: instance (Conflict p) => Conflict (FL p)
- Darcs.Patch.Prim: instance (Conflict p) => Conflict (RL p)
- Darcs.Patch.Prim: instance (Effect p) => Effect (FL p)
- Darcs.Patch.Prim: instance (Effect p) => Effect (RL p)
- Darcs.Patch.Prim: instance (FromPrim p) => FromPrims (FL p)
- Darcs.Patch.Prim: instance (FromPrim p) => FromPrims (RL p)
- Darcs.Patch.Read: instance (ReadPatch p) => ReadPatch (Named p)
- Darcs.RepoPath: instance (CharLike c) => FilePathLike [c]
- Darcs.RepoPath: instance (CharLike c) => FilePathOrURL [c]
- Darcs.Repository.Internal: identifyDarcs1Repository :: [DarcsFlag] -> String -> IO (Repository Patch)
- Darcs.Witnesses.Ordered: instance (MyEq a) => Eq (Sealed a)
- Darcs.Witnesses.Ordered: instance (Show2 a) => Show (FL a)
- Darcs.Witnesses.Ordered: instance (Show2 a) => Show2 (FL a)
- Darcs.Witnesses.Sealed: instance (Show1 a) => Show (Sealed a)
- Darcs.Witnesses.Sealed: instance (Show2 a) => Show (Sealed2 a)
+ Darcs.Arguments: DarcsInternalOption :: DarcsFlag -> DarcsAtomicOption
+ Darcs.Commands: commandProgramName :: DarcsCommand -> String
+ Darcs.CommandsAux: isMaliciousPath :: String -> Bool
+ Darcs.CommandsAux: isMaliciousSubPath :: String -> Bool
+ Darcs.Hopefully: instance Apply p => Apply (PatchInfoAnd p)
+ Darcs.Hopefully: instance Commute p => Commute (PatchInfoAnd p)
+ Darcs.Hopefully: instance Conflict p => Conflict (PatchInfoAnd p)
+ Darcs.Hopefully: instance Effect p => Effect (PatchInfoAnd p)
+ Darcs.Hopefully: instance Invert p => Invert (PatchInfoAnd p)
+ Darcs.Hopefully: instance MyEq p => MyEq (PatchInfoAnd p)
+ Darcs.Hopefully: instance ReadPatch p => ReadPatch (PatchInfoAnd p)
+ Darcs.Hopefully: instance RepoPatch p => Patchy (PatchInfoAnd p)
+ Darcs.Patch: instance RepoPatchBase p => RepoPatch (FL p)
+ Darcs.Patch.Apply: instance Apply p => Apply (Named p)
+ Darcs.Patch.Choices: instance Commute p => Commute (PatchChoice p)
+ Darcs.Patch.Choices: instance Commute p => Commute (TaggedPatch p)
+ Darcs.Patch.Choices: instance Invert p => Invert (TaggedPatch p)
+ Darcs.Patch.Choices: instance MyEq p => MyEq (PatchChoice p)
+ Darcs.Patch.Choices: instance MyEq p => MyEq (TaggedPatch p)
+ Darcs.Patch.Commute: instance Commute p => Commute (Named p)
+ Darcs.Patch.Commute: instance Conflict p => Conflict (Named p)
+ Darcs.Patch.Commute: instance Invert p => Invert (Named p)
+ Darcs.Patch.Commute: instance MyEq p => MyEq (Named p)
+ Darcs.Patch.Core: instance Effect p => Effect (Named p)
+ Darcs.Patch.Non: instance Show2 p => Show (Non p)
+ Darcs.Patch.Non: instance Show2 p => Show1 (Non p)
+ Darcs.Patch.Patchy: instance Apply p => Apply (FL p)
+ Darcs.Patch.Patchy: instance Apply p => Apply (RL p)
+ Darcs.Patch.Patchy: instance Commute p => Commute (FL p)
+ Darcs.Patch.Patchy: instance Commute p => Commute (RL p)
+ Darcs.Patch.Patchy: instance ReadPatch p => ReadPatch (FL p)
+ Darcs.Patch.Patchy: instance ReadPatch p => ReadPatch (RL p)
+ Darcs.Patch.Prim: instance Conflict p => Conflict (FL p)
+ Darcs.Patch.Prim: instance Conflict p => Conflict (RL p)
+ Darcs.Patch.Prim: instance Effect p => Effect (FL p)
+ Darcs.Patch.Prim: instance Effect p => Effect (RL p)
+ Darcs.Patch.Prim: instance FromPrim p => FromPrims (FL p)
+ Darcs.Patch.Prim: instance FromPrim p => FromPrims (RL p)
+ Darcs.Patch.Read: instance ReadPatch p => ReadPatch (Named p)
+ Darcs.RepoPath: instance CharLike c => FilePathLike [c]
+ Darcs.RepoPath: instance CharLike c => FilePathOrURL [c]
+ Darcs.Repository.HashedIO: RW :: RW
+ Darcs.Repository.HashedIO: data RW
+ Darcs.Repository.Internal: identifyDarcsRepository :: [DarcsFlag] -> String -> IO (Repository p)
+ Darcs.Witnesses.Ordered: instance MyEq a => Eq (Sealed a)
+ Darcs.Witnesses.Ordered: instance Show2 a => Show (FL a)
+ Darcs.Witnesses.Ordered: instance Show2 a => Show2 (FL a)
+ Darcs.Witnesses.Sealed: instance Show1 a => Show (Sealed a)
+ Darcs.Witnesses.Sealed: instance Show2 a => Show (Sealed2 a)
- Darcs.Arguments: NoSetDefault :: DarcsFlag
+ Darcs.Arguments: NoSetDefault :: Bool -> DarcsFlag
- Darcs.Arguments: SetDefault :: DarcsFlag
+ Darcs.Arguments: SetDefault :: Bool -> DarcsFlag
- Darcs.Arguments: defineChanges :: (Patchy p) => p -> IO ()
+ Darcs.Arguments: defineChanges :: Patchy p => p -> IO ()
- Darcs.Arguments: definePatches :: (RepoPatch p) => FL (PatchInfoAnd p) -> IO ()
+ Darcs.Arguments: definePatches :: RepoPatch p => FL (PatchInfoAnd p) -> IO ()
- Darcs.Arguments: printDryRunMessageAndExit :: (RepoPatch p) => String -> [DarcsFlag] -> FL (PatchInfoAnd p) -> IO ()
+ Darcs.Arguments: printDryRunMessageAndExit :: RepoPatch p => String -> [DarcsFlag] -> FL (PatchInfoAnd p) -> IO ()
- Darcs.Arguments: showFriendly :: (Patchy p) => [DarcsFlag] -> p -> Doc
+ Darcs.Arguments: showFriendly :: Patchy p => [DarcsFlag] -> p -> Doc
- Darcs.Commands: DarcsCommand :: String -> String -> String -> Int -> [String] -> ([DarcsFlag] -> [String] -> IO ()) -> ([DarcsFlag] -> IO (Either String ())) -> IO [String] -> ([DarcsFlag] -> AbsolutePath -> [String] -> IO [String]) -> [DarcsOption] -> [DarcsOption] -> DarcsCommand
+ Darcs.Commands: DarcsCommand :: String -> String -> String -> String -> Int -> [String] -> ([DarcsFlag] -> [String] -> IO ()) -> ([DarcsFlag] -> IO (Either String ())) -> IO [String] -> ([DarcsFlag] -> AbsolutePath -> [String] -> IO [String]) -> [DarcsOption] -> [DarcsOption] -> DarcsCommand
- Darcs.Commands: SuperCommand :: String -> String -> String -> ([DarcsFlag] -> IO (Either String ())) -> [CommandControl] -> DarcsCommand
+ Darcs.Commands: SuperCommand :: String -> String -> String -> String -> ([DarcsFlag] -> IO (Either String ())) -> [CommandControl] -> DarcsCommand
- Darcs.Commands.Record: askAboutDepends :: (RepoPatch p) => Repository p -> FL Prim -> [DarcsFlag] -> [PatchInfo] -> IO [PatchInfo]
+ Darcs.Commands.Record: askAboutDepends :: RepoPatch p => Repository p -> FL Prim -> [DarcsFlag] -> [PatchInfo] -> IO [PatchInfo]
- Darcs.Commands.Unrecord: getLastPatches :: (RepoPatch p) => [DarcsFlag] -> PatchSet p -> FlippedSeal (RL (PatchInfoAnd p))
+ Darcs.Commands.Unrecord: getLastPatches :: RepoPatch p => [DarcsFlag] -> PatchSet p -> FlippedSeal (RL (PatchInfoAnd p))
- Darcs.Commands.Unrevert: writeUnrevert :: (RepoPatch p) => Repository p -> FL Prim -> Tree IO -> FL Prim -> IO ()
+ Darcs.Commands.Unrevert: writeUnrevert :: RepoPatch p => Repository p -> FL Prim -> Tree IO -> FL Prim -> IO ()
- Darcs.Commands.WhatsNew: announceFiles :: (RepoPatch p) => Repository p -> [SubPath] -> String -> IO [SubPath]
+ Darcs.Commands.WhatsNew: announceFiles :: RepoPatch p => Repository p -> [SubPath] -> String -> IO [SubPath]
- Darcs.CommandsAux: checkPaths :: (Patchy p) => [DarcsFlag] -> FL p -> IO ()
+ Darcs.CommandsAux: checkPaths :: Patchy p => [DarcsFlag] -> FL p -> IO ()
- Darcs.CommandsAux: hasMaliciousPath :: (Patchy p) => p -> Bool
+ Darcs.CommandsAux: hasMaliciousPath :: Patchy p => p -> Bool
- Darcs.CommandsAux: maliciousPatches :: (Patchy p) => [Sealed2 p] -> [Sealed2 p]
+ Darcs.CommandsAux: maliciousPatches :: Patchy p => [Sealed2 p] -> [Sealed2 p]
- Darcs.Flags: NoSetDefault :: DarcsFlag
+ Darcs.Flags: NoSetDefault :: Bool -> DarcsFlag
- Darcs.Flags: SetDefault :: DarcsFlag
+ Darcs.Flags: SetDefault :: Bool -> DarcsFlag
- Darcs.Hopefully: hopefullyM :: (Monad m) => PatchInfoAnd p -> m (Named p)
+ Darcs.Hopefully: hopefullyM :: Monad m => PatchInfoAnd p -> m (Named p)
- Darcs.IO: class (ReadableDirectory m) => WriteableDirectory m
+ Darcs.IO: class ReadableDirectory m => WriteableDirectory m
- Darcs.IO: mCreateDirectory :: (WriteableDirectory m) => FileName -> m ()
+ Darcs.IO: mCreateDirectory :: WriteableDirectory m => FileName -> m ()
- Darcs.IO: mCreateFile :: (WriteableDirectory m) => FileName -> m ()
+ Darcs.IO: mCreateFile :: WriteableDirectory m => FileName -> m ()
- Darcs.IO: mDoesDirectoryExist :: (ReadableDirectory m) => FileName -> m Bool
+ Darcs.IO: mDoesDirectoryExist :: ReadableDirectory m => FileName -> m Bool
- Darcs.IO: mDoesFileExist :: (ReadableDirectory m) => FileName -> m Bool
+ Darcs.IO: mDoesFileExist :: ReadableDirectory m => FileName -> m Bool
- Darcs.IO: mGetDirectoryContents :: (ReadableDirectory m) => m [FileName]
+ Darcs.IO: mGetDirectoryContents :: ReadableDirectory m => m [FileName]
- Darcs.IO: mInCurrentDirectory :: (ReadableDirectory m) => FileName -> m a -> m a
+ Darcs.IO: mInCurrentDirectory :: ReadableDirectory m => FileName -> m a -> m a
- Darcs.IO: mModifyFilePS :: (WriteableDirectory m) => FileName -> (ByteString -> m ByteString) -> m ()
+ Darcs.IO: mModifyFilePS :: WriteableDirectory m => FileName -> (ByteString -> m ByteString) -> m ()
- Darcs.IO: mModifyFilePSs :: (WriteableDirectory m) => FileName -> ([ByteString] -> m [ByteString]) -> m ()
+ Darcs.IO: mModifyFilePSs :: WriteableDirectory m => FileName -> ([ByteString] -> m [ByteString]) -> m ()
- Darcs.IO: mReadBinFile :: (ReadableDirectory m) => FileName -> m String
+ Darcs.IO: mReadBinFile :: ReadableDirectory m => FileName -> m String
- Darcs.IO: mReadFilePS :: (ReadableDirectory m) => FileName -> m ByteString
+ Darcs.IO: mReadFilePS :: ReadableDirectory m => FileName -> m ByteString
- Darcs.IO: mReadFilePSs :: (ReadableDirectory m) => FileName -> m [ByteString]
+ Darcs.IO: mReadFilePSs :: ReadableDirectory m => FileName -> m [ByteString]
- Darcs.IO: mRemoveDirectory :: (WriteableDirectory m) => FileName -> m ()
+ Darcs.IO: mRemoveDirectory :: WriteableDirectory m => FileName -> m ()
- Darcs.IO: mRemoveFile :: (WriteableDirectory m) => FileName -> m ()
+ Darcs.IO: mRemoveFile :: WriteableDirectory m => FileName -> m ()
- Darcs.IO: mRename :: (WriteableDirectory m) => FileName -> FileName -> m ()
+ Darcs.IO: mRename :: WriteableDirectory m => FileName -> FileName -> m ()
- Darcs.IO: mSetFileExecutable :: (WriteableDirectory m) => FileName -> Bool -> m ()
+ Darcs.IO: mSetFileExecutable :: WriteableDirectory m => FileName -> Bool -> m ()
- Darcs.IO: mWithCurrentDirectory :: (WriteableDirectory m) => FileName -> m a -> m a
+ Darcs.IO: mWithCurrentDirectory :: WriteableDirectory m => FileName -> m a -> m a
- Darcs.IO: mWriteBinFile :: (WriteableDirectory m) => FileName -> String -> m ()
+ Darcs.IO: mWriteBinFile :: WriteableDirectory m => FileName -> String -> m ()
- Darcs.IO: mWriteDoc :: (WriteableDirectory m) => FileName -> Doc -> m ()
+ Darcs.IO: mWriteDoc :: WriteableDirectory m => FileName -> Doc -> m ()
- Darcs.IO: mWriteFilePS :: (WriteableDirectory m) => FileName -> ByteString -> m ()
+ Darcs.IO: mWriteFilePS :: WriteableDirectory m => FileName -> ByteString -> m ()
- Darcs.IO: mWriteFilePSs :: (WriteableDirectory m) => FileName -> [ByteString] -> m ()
+ Darcs.IO: mWriteFilePSs :: WriteableDirectory m => FileName -> [ByteString] -> m ()
- Darcs.Lock: appendBinFile :: (FilePathLike p) => p -> String -> IO ()
+ Darcs.Lock: appendBinFile :: FilePathLike p => p -> String -> IO ()
- Darcs.Lock: appendDocBinFile :: (FilePathLike p) => p -> Doc -> IO ()
+ Darcs.Lock: appendDocBinFile :: FilePathLike p => p -> Doc -> IO ()
- Darcs.Lock: appendToFile :: (FilePathLike p) => p -> (Handle -> IO ()) -> IO ()
+ Darcs.Lock: appendToFile :: FilePathLike p => p -> (Handle -> IO ()) -> IO ()
- Darcs.Lock: gzWriteAtomicFilePS :: (FilePathLike p) => p -> ByteString -> IO ()
+ Darcs.Lock: gzWriteAtomicFilePS :: FilePathLike p => p -> ByteString -> IO ()
- Darcs.Lock: gzWriteAtomicFilePSs :: (FilePathLike p) => p -> [ByteString] -> IO ()
+ Darcs.Lock: gzWriteAtomicFilePSs :: FilePathLike p => p -> [ByteString] -> IO ()
- Darcs.Lock: gzWriteDocFile :: (FilePathLike p) => p -> Doc -> IO ()
+ Darcs.Lock: gzWriteDocFile :: FilePathLike p => p -> Doc -> IO ()
- Darcs.Lock: readBinFile :: (FilePathLike p) => p -> IO String
+ Darcs.Lock: readBinFile :: FilePathLike p => p -> IO String
- Darcs.Lock: readDocBinFile :: (FilePathLike p) => p -> IO Doc
+ Darcs.Lock: readDocBinFile :: FilePathLike p => p -> IO Doc
- Darcs.Lock: readLocaleFile :: (FilePathLike p) => p -> IO String
+ Darcs.Lock: readLocaleFile :: FilePathLike p => p -> IO String
- Darcs.Lock: removeFileMayNotExist :: (FilePathLike p) => p -> IO ()
+ Darcs.Lock: removeFileMayNotExist :: FilePathLike p => p -> IO ()
- Darcs.Lock: writeAtomicFilePS :: (FilePathLike p) => p -> ByteString -> IO ()
+ Darcs.Lock: writeAtomicFilePS :: FilePathLike p => p -> ByteString -> IO ()
- Darcs.Lock: writeBinFile :: (FilePathLike p) => p -> String -> IO ()
+ Darcs.Lock: writeBinFile :: FilePathLike p => p -> String -> IO ()
- Darcs.Lock: writeDocBinFile :: (FilePathLike p) => p -> Doc -> IO ()
+ Darcs.Lock: writeDocBinFile :: FilePathLike p => p -> Doc -> IO ()
- Darcs.Lock: writeLocaleFile :: (FilePathLike p) => p -> String -> IO ()
+ Darcs.Lock: writeLocaleFile :: FilePathLike p => p -> String -> IO ()
- Darcs.Lock: writeToFile :: (FilePathLike p) => p -> (Handle -> IO ()) -> IO ()
+ Darcs.Lock: writeToFile :: FilePathLike p => p -> (Handle -> IO ()) -> IO ()
- Darcs.Match: getFirstMatch :: (RepoPatch p) => Repository p -> [DarcsFlag] -> IO ()
+ Darcs.Match: getFirstMatch :: RepoPatch p => Repository p -> [DarcsFlag] -> IO ()
- Darcs.Match: getNonrangeMatch :: (RepoPatch p) => Repository p -> [DarcsFlag] -> IO ()
+ Darcs.Match: getNonrangeMatch :: RepoPatch p => Repository p -> [DarcsFlag] -> IO ()
- Darcs.Match: getOnePatchset :: (RepoPatch p) => Repository p -> [DarcsFlag] -> IO (SealedPatchSet p)
+ Darcs.Match: getOnePatchset :: RepoPatch p => Repository p -> [DarcsFlag] -> IO (SealedPatchSet p)
- Darcs.Match: getPartialFirstMatch :: (RepoPatch p) => Repository p -> [DarcsFlag] -> [FileName] -> IO ()
+ Darcs.Match: getPartialFirstMatch :: RepoPatch p => Repository p -> [DarcsFlag] -> [FileName] -> IO ()
- Darcs.Match: getPartialNonrangeMatch :: (RepoPatch p) => Repository p -> [DarcsFlag] -> [FileName] -> IO ()
+ Darcs.Match: getPartialNonrangeMatch :: RepoPatch p => Repository p -> [DarcsFlag] -> [FileName] -> IO ()
- Darcs.Match: getPartialSecondMatch :: (RepoPatch p) => Repository p -> [DarcsFlag] -> [FileName] -> IO ()
+ Darcs.Match: getPartialSecondMatch :: RepoPatch p => Repository p -> [DarcsFlag] -> [FileName] -> IO ()
- Darcs.Match: matchAPatch :: (Patchy p) => [DarcsFlag] -> Named p -> Bool
+ Darcs.Match: matchAPatch :: Patchy p => [DarcsFlag] -> Named p -> Bool
- Darcs.Match: matchAPatchread :: (Patchy p) => [DarcsFlag] -> PatchInfoAnd p -> Bool
+ Darcs.Match: matchAPatchread :: Patchy p => [DarcsFlag] -> PatchInfoAnd p -> Bool
- Darcs.Match: matchFirstPatchset :: (RepoPatch p) => [DarcsFlag] -> PatchSet p -> SealedPatchSet p
+ Darcs.Match: matchFirstPatchset :: RepoPatch p => [DarcsFlag] -> PatchSet p -> SealedPatchSet p
- Darcs.Match: matchPatch :: (RepoPatch p) => [DarcsFlag] -> PatchSet p -> Sealed2 (Named p)
+ Darcs.Match: matchPatch :: RepoPatch p => [DarcsFlag] -> PatchSet p -> Sealed2 (Named p)
- Darcs.Match: matchSecondPatchset :: (RepoPatch p) => [DarcsFlag] -> PatchSet p -> SealedPatchSet p
+ Darcs.Match: matchSecondPatchset :: RepoPatch p => [DarcsFlag] -> PatchSet p -> SealedPatchSet p
- Darcs.Match: nonrangeMatcher :: (Patchy p) => [DarcsFlag] -> Maybe (Matcher p)
+ Darcs.Match: nonrangeMatcher :: Patchy p => [DarcsFlag] -> Maybe (Matcher p)
- Darcs.Patch: anonymous :: (Patchy p) => p -> IO (Named p)
+ Darcs.Patch: anonymous :: Patchy p => p -> IO (Named p)
- Darcs.Patch: applyToFilepaths :: (Apply p) => p -> [FilePath] -> [FilePath]
+ Darcs.Patch: applyToFilepaths :: Apply p => p -> [FilePath] -> [FilePath]
- Darcs.Patch: applyToTree :: (Apply p) => p -> Tree IO -> IO (Tree IO)
+ Darcs.Patch: applyToTree :: Apply p => p -> Tree IO -> IO (Tree IO)
- Darcs.Patch: commute :: (Commute p) => (p :> p) -> Maybe ((p :> p))
+ Darcs.Patch: commute :: Commute p => (p :> p) -> Maybe ((p :> p))
- Darcs.Patch: commuteFLorComplain :: (Commute p) => (p :> FL p) -> Either (Sealed2 p) ((FL p :> p))
+ Darcs.Patch: commuteFLorComplain :: Commute p => (p :> FL p) -> Either (Sealed2 p) ((FL p :> p))
- Darcs.Patch: commuteRL :: (Commute p) => (RL p :> p) -> Maybe ((p :> RL p))
+ Darcs.Patch: commuteRL :: Commute p => (RL p :> p) -> Maybe ((p :> RL p))
- Darcs.Patch: description :: (ShowPatch p) => p -> Doc
+ Darcs.Patch: description :: ShowPatch p => p -> Doc
- Darcs.Patch: effect :: (Effect p) => p -> FL Prim
+ Darcs.Patch: effect :: Effect p => p -> FL Prim
- Darcs.Patch: fromPrim :: (FromPrim p) => Prim -> p
+ Darcs.Patch: fromPrim :: FromPrim p => Prim -> p
- Darcs.Patch: fromPrims :: (FromPrims p) => FL Prim -> p
+ Darcs.Patch: fromPrims :: FromPrims p => FL Prim -> p
- Darcs.Patch: gzWritePatch :: (ShowPatch p) => FilePath -> p -> IO ()
+ Darcs.Patch: gzWritePatch :: ShowPatch p => FilePath -> p -> IO ()
- Darcs.Patch: hunkMatches :: (Commute p) => (ByteString -> Bool) -> p -> Bool
+ Darcs.Patch: hunkMatches :: Commute p => (ByteString -> Bool) -> p -> Bool
- Darcs.Patch: identity :: (Invert p) => p
+ Darcs.Patch: identity :: Invert p => p
- Darcs.Patch: infopatch :: (Patchy p) => PatchInfo -> p -> Named p
+ Darcs.Patch: infopatch :: Patchy p => PatchInfo -> p -> Named p
- Darcs.Patch: invert :: (Invert p) => p -> p
+ Darcs.Patch: invert :: Invert p => p -> p
- Darcs.Patch: invertFL :: (Invert p) => FL p -> RL p
+ Darcs.Patch: invertFL :: Invert p => FL p -> RL p
- Darcs.Patch: invertRL :: (Invert p) => RL p -> FL p
+ Darcs.Patch: invertRL :: Invert p => RL p -> FL p
- Darcs.Patch: isInconsistent :: (Conflict p) => p -> Maybe Doc
+ Darcs.Patch: isInconsistent :: Conflict p => p -> Maybe Doc
- Darcs.Patch: joinPatches :: (FromPrims p) => FL p -> p
+ Darcs.Patch: joinPatches :: FromPrims p => FL p -> p
- Darcs.Patch: listConflictedFiles :: (Conflict p) => p -> [FilePath]
+ Darcs.Patch: listConflictedFiles :: Conflict p => p -> [FilePath]
- Darcs.Patch: listTouchedFiles :: (Commute p) => p -> [FilePath]
+ Darcs.Patch: listTouchedFiles :: Commute p => p -> [FilePath]
- Darcs.Patch: markupFile :: (Effect p) => PatchInfo -> p -> (FilePath, MarkedUpFile) -> (FilePath, MarkedUpFile)
+ Darcs.Patch: markupFile :: Effect p => PatchInfo -> p -> (FilePath, MarkedUpFile) -> (FilePath, MarkedUpFile)
- Darcs.Patch: merge :: (Commute p) => (p :\/: p) -> (p :/\: p)
+ Darcs.Patch: merge :: Commute p => (p :\/: p) -> (p :/\: p)
- Darcs.Patch: namepatch :: (Patchy p) => String -> String -> String -> [String] -> p -> IO (Named p)
+ Darcs.Patch: namepatch :: Patchy p => String -> String -> String -> [String] -> p -> IO (Named p)
- Darcs.Patch: readPatch :: (ReadPatch p) => ByteString -> Maybe (Sealed (p), ByteString)
+ Darcs.Patch: readPatch :: ReadPatch p => ByteString -> Maybe (Sealed (p), ByteString)
- Darcs.Patch: resolveConflicts :: (Conflict p) => p -> [[Sealed (FL Prim)]]
+ Darcs.Patch: resolveConflicts :: Conflict p => p -> [[Sealed (FL Prim)]]
- Darcs.Patch: showContextPatch :: (ShowPatch p) => p -> TreeIO Doc
+ Darcs.Patch: showContextPatch :: ShowPatch p => p -> TreeIO Doc
- Darcs.Patch: showNicely :: (ShowPatch p) => p -> Doc
+ Darcs.Patch: showNicely :: ShowPatch p => p -> Doc
- Darcs.Patch: showPatch :: (ShowPatch p) => p -> Doc
+ Darcs.Patch: showPatch :: ShowPatch p => p -> Doc
- Darcs.Patch: summary :: (ShowPatch p) => p -> Doc
+ Darcs.Patch: summary :: ShowPatch p => p -> Doc
- Darcs.Patch: thing :: (ShowPatch p) => p -> String
+ Darcs.Patch: thing :: ShowPatch p => p -> String
- Darcs.Patch: things :: (ShowPatch p) => p -> String
+ Darcs.Patch: things :: ShowPatch p => p -> String
- Darcs.Patch: writePatch :: (ShowPatch p) => FilePath -> p -> IO ()
+ Darcs.Patch: writePatch :: ShowPatch p => FilePath -> p -> IO ()
- Darcs.Patch.Apply: applyToFilepaths :: (Apply p) => p -> [FilePath] -> [FilePath]
+ Darcs.Patch.Apply: applyToFilepaths :: Apply p => p -> [FilePath] -> [FilePath]
- Darcs.Patch.Apply: applyToTree :: (Apply p) => p -> Tree IO -> IO (Tree IO)
+ Darcs.Patch.Apply: applyToTree :: Apply p => p -> Tree IO -> IO (Tree IO)
- Darcs.Patch.Apply: markupFile :: (Effect p) => PatchInfo -> p -> (FilePath, MarkedUpFile) -> (FilePath, MarkedUpFile)
+ Darcs.Patch.Apply: markupFile :: Effect p => PatchInfo -> p -> (FilePath, MarkedUpFile) -> (FilePath, MarkedUpFile)
- Darcs.Patch.Bundle: contextPatches :: (RepoPatch p) => PatchSet p -> FlippedSeal (RL (PatchInfoAnd p))
+ Darcs.Patch.Bundle: contextPatches :: RepoPatch p => PatchSet p -> FlippedSeal (RL (PatchInfoAnd p))
- Darcs.Patch.Bundle: hashBundle :: (RepoPatch p) => [PatchInfo] -> FL (Named p) -> String
+ Darcs.Patch.Bundle: hashBundle :: RepoPatch p => [PatchInfo] -> FL (Named p) -> String
- Darcs.Patch.Bundle: makeBundle :: (RepoPatch p) => Maybe (Tree IO) -> RL (PatchInfoAnd p) -> FL (Named p) -> IO Doc
+ Darcs.Patch.Bundle: makeBundle :: RepoPatch p => Maybe (Tree IO) -> RL (PatchInfoAnd p) -> FL (Named p) -> IO Doc
- Darcs.Patch.Bundle: makeBundle2 :: (RepoPatch p) => Maybe (Tree IO) -> RL (PatchInfoAnd p) -> FL (Named p) -> FL (Named p) -> IO Doc
+ Darcs.Patch.Bundle: makeBundle2 :: RepoPatch p => Maybe (Tree IO) -> RL (PatchInfoAnd p) -> FL (Named p) -> FL (Named p) -> IO Doc
- Darcs.Patch.Bundle: makeBundleN :: (RepoPatch p) => Maybe (Tree IO) -> PatchSet p -> FL (Named p) -> IO Doc
+ Darcs.Patch.Bundle: makeBundleN :: RepoPatch p => Maybe (Tree IO) -> PatchSet p -> FL (Named p) -> IO Doc
- Darcs.Patch.Bundle: scanBundle :: (RepoPatch p) => ByteString -> Either String (SealedPatchSet p)
+ Darcs.Patch.Bundle: scanBundle :: RepoPatch p => ByteString -> Either String (SealedPatchSet p)
- Darcs.Patch.Bundle: scanContext :: (RepoPatch p) => ByteString -> PatchSet p
+ Darcs.Patch.Bundle: scanContext :: RepoPatch p => ByteString -> PatchSet p
- Darcs.Patch.Choices: forceFirst :: (Patchy p) => Tag -> PatchChoices p -> PatchChoices p
+ Darcs.Patch.Choices: forceFirst :: Patchy p => Tag -> PatchChoices p -> PatchChoices p
- Darcs.Patch.Choices: forceFirsts :: (Patchy p) => [Tag] -> PatchChoices p -> PatchChoices p
+ Darcs.Patch.Choices: forceFirsts :: Patchy p => [Tag] -> PatchChoices p -> PatchChoices p
- Darcs.Patch.Choices: forceLast :: (Patchy p) => Tag -> PatchChoices p -> PatchChoices p
+ Darcs.Patch.Choices: forceLast :: Patchy p => Tag -> PatchChoices p -> PatchChoices p
- Darcs.Patch.Choices: forceLasts :: (Patchy p) => [Tag] -> PatchChoices p -> PatchChoices p
+ Darcs.Patch.Choices: forceLasts :: Patchy p => [Tag] -> PatchChoices p -> PatchChoices p
- Darcs.Patch.Choices: forceMatchingFirst :: (Patchy p) => (TaggedPatch p -> Bool) -> PatchChoices p -> PatchChoices p
+ Darcs.Patch.Choices: forceMatchingFirst :: Patchy p => (TaggedPatch p -> Bool) -> PatchChoices p -> PatchChoices p
- Darcs.Patch.Choices: forceMatchingLast :: (Patchy p) => (TaggedPatch p -> Bool) -> PatchChoices p -> PatchChoices p
+ Darcs.Patch.Choices: forceMatchingLast :: Patchy p => (TaggedPatch p -> Bool) -> PatchChoices p -> PatchChoices p
- Darcs.Patch.Choices: getChoices :: (Patchy p) => PatchChoices p -> (FL (TaggedPatch p) :> (FL (TaggedPatch p) :> FL (TaggedPatch p)))
+ Darcs.Patch.Choices: getChoices :: Patchy p => PatchChoices p -> (FL (TaggedPatch p) :> (FL (TaggedPatch p) :> FL (TaggedPatch p)))
- Darcs.Patch.Choices: makeEverythingLater :: (Patchy p) => PatchChoices p -> PatchChoices p
+ Darcs.Patch.Choices: makeEverythingLater :: Patchy p => PatchChoices p -> PatchChoices p
- Darcs.Patch.Choices: makeEverythingSooner :: (Patchy p) => PatchChoices p -> PatchChoices p
+ Darcs.Patch.Choices: makeEverythingSooner :: Patchy p => PatchChoices p -> PatchChoices p
- Darcs.Patch.Choices: makeUncertain :: (Patchy p) => Tag -> PatchChoices p -> PatchChoices p
+ Darcs.Patch.Choices: makeUncertain :: Patchy p => Tag -> PatchChoices p -> PatchChoices p
- Darcs.Patch.Choices: patchChoices :: (Patchy p) => FL p -> PatchChoices p
+ Darcs.Patch.Choices: patchChoices :: Patchy p => FL p -> PatchChoices p
- Darcs.Patch.Choices: patchChoicesTps :: (Patchy p) => FL p -> (PatchChoices p, FL (TaggedPatch p))
+ Darcs.Patch.Choices: patchChoicesTps :: Patchy p => FL p -> (PatchChoices p, FL (TaggedPatch p))
- Darcs.Patch.Choices: patchChoicesTpsSub :: (Patchy p) => Maybe Tag -> FL p -> (PatchChoices p, FL (TaggedPatch p))
+ Darcs.Patch.Choices: patchChoicesTpsSub :: Patchy p => Maybe Tag -> FL p -> (PatchChoices p, FL (TaggedPatch p))
- Darcs.Patch.Choices: patchSlot :: (Patchy p) => TaggedPatch p -> PatchChoices p -> (Slot, PatchChoices p)
+ Darcs.Patch.Choices: patchSlot :: Patchy p => TaggedPatch p -> PatchChoices p -> (Slot, PatchChoices p)
- Darcs.Patch.Choices: patchSlot' :: (Patchy p) => TaggedPatch p -> State (PatchChoices p) Slot
+ Darcs.Patch.Choices: patchSlot' :: Patchy p => TaggedPatch p -> StateT (PatchChoices p) Identity Slot
- Darcs.Patch.Choices: selectAllMiddles :: (Patchy p) => Bool -> PatchChoices p -> PatchChoices p
+ Darcs.Patch.Choices: selectAllMiddles :: Patchy p => Bool -> PatchChoices p -> PatchChoices p
- Darcs.Patch.Choices: separateFirstFromMiddleLast :: (Patchy p) => PatchChoices p -> (FL (TaggedPatch p) :> FL (TaggedPatch p))
+ Darcs.Patch.Choices: separateFirstFromMiddleLast :: Patchy p => PatchChoices p -> (FL (TaggedPatch p) :> FL (TaggedPatch p))
- Darcs.Patch.Choices: separateFirstMiddleFromLast :: (Patchy p) => PatchChoices p -> (FL (TaggedPatch p) :> FL (TaggedPatch p))
+ Darcs.Patch.Choices: separateFirstMiddleFromLast :: Patchy p => PatchChoices p -> (FL (TaggedPatch p) :> FL (TaggedPatch p))
- Darcs.Patch.Choices: substitute :: (Patchy p) => Sealed2 (TaggedPatch p :||: FL (TaggedPatch p)) -> PatchChoices p -> PatchChoices p
+ Darcs.Patch.Choices: substitute :: Patchy p => Sealed2 (TaggedPatch p :||: FL (TaggedPatch p)) -> PatchChoices p -> PatchChoices p
- Darcs.Patch.Commute: fromPrims :: (FromPrims p) => FL Prim -> p
+ Darcs.Patch.Commute: fromPrims :: FromPrims p => FL Prim -> p
- Darcs.Patch.Commute: merge :: (Commute p) => (p :\/: p) -> (p :/\: p)
+ Darcs.Patch.Commute: merge :: Commute p => (p :\/: p) -> (p :/\: p)
- Darcs.Patch.Core: anonymous :: (Patchy p) => p -> IO (Named p)
+ Darcs.Patch.Core: anonymous :: Patchy p => p -> IO (Named p)
- Darcs.Patch.Core: infopatch :: (Patchy p) => PatchInfo -> p -> Named p
+ Darcs.Patch.Core: infopatch :: Patchy p => PatchInfo -> p -> Named p
- Darcs.Patch.Core: namepatch :: (Patchy p) => String -> String -> String -> [String] -> p -> IO (Named p)
+ Darcs.Patch.Core: namepatch :: Patchy p => String -> String -> String -> [String] -> p -> IO (Named p)
- Darcs.Patch.Depends: areUnrelatedRepos :: (RepoPatch p) => PatchSet p -> PatchSet p -> Bool
+ Darcs.Patch.Depends: areUnrelatedRepos :: RepoPatch p => PatchSet p -> PatchSet p -> Bool
- Darcs.Patch.Depends: commuteToEnd :: (RepoPatch p) => RL (PatchInfoAnd p) -> PatchSet p -> (PatchSet p :>> RL (PatchInfoAnd p))
+ Darcs.Patch.Depends: commuteToEnd :: RepoPatch p => RL (PatchInfoAnd p) -> PatchSet p -> (PatchSet p :>> RL (PatchInfoAnd p))
- Darcs.Patch.Depends: countUsThem :: (RepoPatch p) => PatchSet p -> PatchSet p -> (Int, Int)
+ Darcs.Patch.Depends: countUsThem :: RepoPatch p => PatchSet p -> PatchSet p -> (Int, Int)
- Darcs.Patch.Depends: findCommonWithThem :: (RepoPatch p) => PatchSet p -> PatchSet p -> (PatchSet p :>> FL (PatchInfoAnd p))
+ Darcs.Patch.Depends: findCommonWithThem :: RepoPatch p => PatchSet p -> PatchSet p -> (PatchSet p :>> FL (PatchInfoAnd p))
- Darcs.Patch.Depends: findUncommon :: (RepoPatch p) => PatchSet p -> PatchSet p -> (FL (PatchInfoAnd p) :\/: FL (PatchInfoAnd p))
+ Darcs.Patch.Depends: findUncommon :: RepoPatch p => PatchSet p -> PatchSet p -> (FL (PatchInfoAnd p) :\/: FL (PatchInfoAnd p))
- Darcs.Patch.Depends: getPatchesBeyondTag :: (RepoPatch p) => PatchInfo -> PatchSet p -> FlippedSeal (RL (PatchInfoAnd p))
+ Darcs.Patch.Depends: getPatchesBeyondTag :: RepoPatch p => PatchInfo -> PatchSet p -> FlippedSeal (RL (PatchInfoAnd p))
- Darcs.Patch.Depends: getPatchesInTag :: (RepoPatch p) => PatchInfo -> PatchSet p -> SealedPatchSet p
+ Darcs.Patch.Depends: getPatchesInTag :: RepoPatch p => PatchInfo -> PatchSet p -> SealedPatchSet p
- Darcs.Patch.Depends: merge2FL :: (RepoPatch p) => FL (PatchInfoAnd p) -> FL (PatchInfoAnd p) -> Sealed (FL (PatchInfoAnd p))
+ Darcs.Patch.Depends: merge2FL :: RepoPatch p => FL (PatchInfoAnd p) -> FL (PatchInfoAnd p) -> Sealed (FL (PatchInfoAnd p))
- Darcs.Patch.Depends: mergeThem :: (RepoPatch p) => PatchSet p -> PatchSet p -> Sealed (FL (PatchInfoAnd p))
+ Darcs.Patch.Depends: mergeThem :: RepoPatch p => PatchSet p -> PatchSet p -> Sealed (FL (PatchInfoAnd p))
- Darcs.Patch.Depends: newsetIntersection :: (RepoPatch p) => [SealedPatchSet p] -> SealedPatchSet p
+ Darcs.Patch.Depends: newsetIntersection :: RepoPatch p => [SealedPatchSet p] -> SealedPatchSet p
- Darcs.Patch.Depends: newsetUnion :: (RepoPatch p) => [SealedPatchSet p] -> SealedPatchSet p
+ Darcs.Patch.Depends: newsetUnion :: RepoPatch p => [SealedPatchSet p] -> SealedPatchSet p
- Darcs.Patch.Depends: removeFromPatchSet :: (RepoPatch p) => FL (PatchInfoAnd p) -> PatchSet p -> Maybe (PatchSet p)
+ Darcs.Patch.Depends: removeFromPatchSet :: RepoPatch p => FL (PatchInfoAnd p) -> PatchSet p -> Maybe (PatchSet p)
- Darcs.Patch.Depends: splitOnTag :: (RepoPatch p) => PatchInfo -> PatchSet p -> (PatchSet p :>> RL (PatchInfoAnd p))
+ Darcs.Patch.Depends: splitOnTag :: RepoPatch p => PatchInfo -> PatchSet p -> (PatchSet p :>> RL (PatchInfoAnd p))
- Darcs.Patch.Match: matchParser :: (Patchy p) => CharParser st (MatchFun p)
+ Darcs.Patch.Match: matchParser :: Patchy p => CharParser st (MatchFun p)
- Darcs.Patch.Match: matchPattern :: (Patchy p) => PatchMatch -> Matcher p
+ Darcs.Patch.Match: matchPattern :: Patchy p => PatchMatch -> Matcher p
- Darcs.Patch.Match: parseMatch :: (Patchy p) => PatchMatch -> Either String (MatchFun p)
+ Darcs.Patch.Match: parseMatch :: Patchy p => PatchMatch -> Either String (MatchFun p)
- Darcs.Patch.Non: non :: (Nonable p) => p -> Non p
+ Darcs.Patch.Non: non :: Nonable p => p -> Non p
- Darcs.Patch.Non: showNon :: (ShowPatch (FL p)) => Non p -> Doc
+ Darcs.Patch.Non: showNon :: ShowPatch (FL p) => Non p -> Doc
- Darcs.Patch.Non: showNons :: (ShowPatch (FL p)) => [Non p] -> Doc
+ Darcs.Patch.Non: showNons :: ShowPatch (FL p) => [Non p] -> Doc
- Darcs.Patch.Non: unNon :: (FromPrim p) => Non p -> Sealed (FL p)
+ Darcs.Patch.Non: unNon :: FromPrim p => Non p -> Sealed (FL p)
- Darcs.Patch.Patchy: class (MyEq p) => Invert p
+ Darcs.Patch.Patchy: class MyEq p => Invert p
- Darcs.Patch.Patchy: class (Commute p) => ShowPatch p
+ Darcs.Patch.Patchy: class Commute p => ShowPatch p
- Darcs.Patch.Patchy: commute :: (Commute p) => (p :> p) -> Maybe ((p :> p))
+ Darcs.Patch.Patchy: commute :: Commute p => (p :> p) -> Maybe ((p :> p))
- Darcs.Patch.Patchy: commuteFL :: (Commute p) => (p :> FL p) -> Maybe ((FL p :> p))
+ Darcs.Patch.Patchy: commuteFL :: Commute p => (p :> FL p) -> Maybe ((FL p :> p))
- Darcs.Patch.Patchy: commuteFLorComplain :: (Commute p) => (p :> FL p) -> Either (Sealed2 p) ((FL p :> p))
+ Darcs.Patch.Patchy: commuteFLorComplain :: Commute p => (p :> FL p) -> Either (Sealed2 p) ((FL p :> p))
- Darcs.Patch.Patchy: commuteRL :: (Commute p) => (RL p :> p) -> Maybe ((p :> RL p))
+ Darcs.Patch.Patchy: commuteRL :: Commute p => (RL p :> p) -> Maybe ((p :> RL p))
- Darcs.Patch.Patchy: commuteRLFL :: (Commute p) => (RL p :> FL p) -> Maybe ((FL p :> RL p))
+ Darcs.Patch.Patchy: commuteRLFL :: Commute p => (RL p :> FL p) -> Maybe ((FL p :> RL p))
- Darcs.Patch.Patchy: description :: (ShowPatch p) => p -> Doc
+ Darcs.Patch.Patchy: description :: ShowPatch p => p -> Doc
- Darcs.Patch.Patchy: gzWritePatch :: (ShowPatch p) => FilePath -> p -> IO ()
+ Darcs.Patch.Patchy: gzWritePatch :: ShowPatch p => FilePath -> p -> IO ()
- Darcs.Patch.Patchy: hunkMatches :: (Commute p) => (ByteString -> Bool) -> p -> Bool
+ Darcs.Patch.Patchy: hunkMatches :: Commute p => (ByteString -> Bool) -> p -> Bool
- Darcs.Patch.Patchy: identity :: (Invert p) => p
+ Darcs.Patch.Patchy: identity :: Invert p => p
- Darcs.Patch.Patchy: invert :: (Invert p) => p -> p
+ Darcs.Patch.Patchy: invert :: Invert p => p -> p
- Darcs.Patch.Patchy: invertFL :: (Invert p) => FL p -> RL p
+ Darcs.Patch.Patchy: invertFL :: Invert p => FL p -> RL p
- Darcs.Patch.Patchy: invertRL :: (Invert p) => RL p -> FL p
+ Darcs.Patch.Patchy: invertRL :: Invert p => RL p -> FL p
- Darcs.Patch.Patchy: listTouchedFiles :: (Commute p) => p -> [FilePath]
+ Darcs.Patch.Patchy: listTouchedFiles :: Commute p => p -> [FilePath]
- Darcs.Patch.Patchy: merge :: (Commute p) => (p :\/: p) -> (p :/\: p)
+ Darcs.Patch.Patchy: merge :: Commute p => (p :\/: p) -> (p :/\: p)
- Darcs.Patch.Patchy: mergeFL :: (Commute p) => (p :\/: FL p) -> (FL p :/\: p)
+ Darcs.Patch.Patchy: mergeFL :: Commute p => (p :\/: FL p) -> (FL p :/\: p)
- Darcs.Patch.Patchy: peekfor :: (ParserM m) => String -> m a -> m a -> m a
+ Darcs.Patch.Patchy: peekfor :: ParserM m => String -> m a -> m a -> m a
- Darcs.Patch.Patchy: showContextPatch :: (ShowPatch p) => p -> TreeIO Doc
+ Darcs.Patch.Patchy: showContextPatch :: ShowPatch p => p -> TreeIO Doc
- Darcs.Patch.Patchy: showNicely :: (ShowPatch p) => p -> Doc
+ Darcs.Patch.Patchy: showNicely :: ShowPatch p => p -> Doc
- Darcs.Patch.Patchy: showPatch :: (ShowPatch p) => p -> Doc
+ Darcs.Patch.Patchy: showPatch :: ShowPatch p => p -> Doc
- Darcs.Patch.Patchy: sloppyIdentity :: (Invert p) => p -> EqCheck
+ Darcs.Patch.Patchy: sloppyIdentity :: Invert p => p -> EqCheck
- Darcs.Patch.Patchy: summary :: (ShowPatch p) => p -> Doc
+ Darcs.Patch.Patchy: summary :: ShowPatch p => p -> Doc
- Darcs.Patch.Patchy: thing :: (ShowPatch p) => p -> String
+ Darcs.Patch.Patchy: thing :: ShowPatch p => p -> String
- Darcs.Patch.Patchy: things :: (ShowPatch p) => p -> String
+ Darcs.Patch.Patchy: things :: ShowPatch p => p -> String
- Darcs.Patch.Patchy: writePatch :: (ShowPatch p) => FilePath -> p -> IO ()
+ Darcs.Patch.Patchy: writePatch :: ShowPatch p => FilePath -> p -> IO ()
- Darcs.Patch.Permutations: commuteWhatWeCanFL :: (Commute p) => (p :> FL p) -> (FL p :> (p :> FL p))
+ Darcs.Patch.Permutations: commuteWhatWeCanFL :: Commute p => (p :> FL p) -> (FL p :> (p :> FL p))
- Darcs.Patch.Permutations: commuteWhatWeCanRL :: (Commute p) => (RL p :> p) -> (RL p :> (p :> RL p))
+ Darcs.Patch.Permutations: commuteWhatWeCanRL :: Commute p => (RL p :> p) -> (RL p :> (p :> RL p))
- Darcs.Patch.Permutations: headPermutationsFL :: (Commute p) => FL p -> [(p :> FL p)]
+ Darcs.Patch.Permutations: headPermutationsFL :: Commute p => FL p -> [(p :> FL p)]
- Darcs.Patch.Permutations: headPermutationsRL :: (Commute p) => RL p -> [RL p]
+ Darcs.Patch.Permutations: headPermutationsRL :: Commute p => RL p -> [RL p]
- Darcs.Patch.Permutations: partitionFL :: (Commute p) => (p -> Bool) -> FL p -> ((FL p :> (FL p :> FL p)))
+ Darcs.Patch.Permutations: partitionFL :: Commute p => (p -> Bool) -> FL p -> ((FL p :> (FL p :> FL p)))
- Darcs.Patch.Permutations: partitionRL :: (Commute p) => (p -> Bool) -> RL p -> (RL p :> RL p)
+ Darcs.Patch.Permutations: partitionRL :: Commute p => (p -> Bool) -> RL p -> (RL p :> RL p)
- Darcs.Patch.Permutations: selfCommuter :: (Commute p) => CommuteFn p p
+ Darcs.Patch.Permutations: selfCommuter :: Commute p => CommuteFn p p
- Darcs.Patch.Permutations: simpleHeadPermutationsFL :: (Commute p) => FL p -> [FL p]
+ Darcs.Patch.Permutations: simpleHeadPermutationsFL :: Commute p => FL p -> [FL p]
- Darcs.Patch.Prim: class (FromPrim p) => ToFromPrim p
+ Darcs.Patch.Prim: class FromPrim p => ToFromPrim p
- Darcs.Patch.Prim: commuteNoConflicts :: (Conflict p) => (p :> p) -> Maybe ((p :> p))
+ Darcs.Patch.Prim: commuteNoConflicts :: Conflict p => (p :> p) -> Maybe ((p :> p))
- Darcs.Patch.Prim: commuteNoConflictsFL :: (Conflict p) => (p :> FL p) -> Maybe ((FL p :> p))
+ Darcs.Patch.Prim: commuteNoConflictsFL :: Conflict p => (p :> FL p) -> Maybe ((FL p :> p))
- Darcs.Patch.Prim: commuteNoConflictsRL :: (Conflict p) => (RL p :> p) -> Maybe ((p :> RL p))
+ Darcs.Patch.Prim: commuteNoConflictsRL :: Conflict p => (RL p :> p) -> Maybe ((p :> RL p))
- Darcs.Patch.Prim: conflictedEffect :: (Conflict p) => p -> [IsConflictedPrim]
+ Darcs.Patch.Prim: conflictedEffect :: Conflict p => p -> [IsConflictedPrim]
- Darcs.Patch.Prim: effect :: (Effect p) => p -> FL Prim
+ Darcs.Patch.Prim: effect :: Effect p => p -> FL Prim
- Darcs.Patch.Prim: effectRL :: (Effect p) => p -> RL Prim
+ Darcs.Patch.Prim: effectRL :: Effect p => p -> RL Prim
- Darcs.Patch.Prim: fromPrim :: (FromPrim p) => Prim -> p
+ Darcs.Patch.Prim: fromPrim :: FromPrim p => Prim -> p
- Darcs.Patch.Prim: fromPrims :: (FromPrims p) => FL Prim -> p
+ Darcs.Patch.Prim: fromPrims :: FromPrims p => FL Prim -> p
- Darcs.Patch.Prim: isHunk :: (Effect p) => p -> Maybe (Prim)
+ Darcs.Patch.Prim: isHunk :: Effect p => p -> Maybe (Prim)
- Darcs.Patch.Prim: isInconsistent :: (Conflict p) => p -> Maybe Doc
+ Darcs.Patch.Prim: isInconsistent :: Conflict p => p -> Maybe Doc
- Darcs.Patch.Prim: joinPatches :: (FromPrims p) => FL p -> p
+ Darcs.Patch.Prim: joinPatches :: FromPrims p => FL p -> p
- Darcs.Patch.Prim: listConflictedFiles :: (Conflict p) => p -> [FilePath]
+ Darcs.Patch.Prim: listConflictedFiles :: Conflict p => p -> [FilePath]
- Darcs.Patch.Prim: resolveConflicts :: (Conflict p) => p -> [[Sealed (FL Prim)]]
+ Darcs.Patch.Prim: resolveConflicts :: Conflict p => p -> [[Sealed (FL Prim)]]
- Darcs.Patch.Prim: toPrim :: (ToFromPrim p) => p -> Maybe (Prim)
+ Darcs.Patch.Prim: toPrim :: ToFromPrim p => p -> Maybe (Prim)
- Darcs.Patch.Properties: commuteInverses :: (Patchy p) => ((p :> p) -> Maybe ((p :> p))) -> (p :> p) -> Maybe Doc
+ Darcs.Patch.Properties: commuteInverses :: Patchy p => ((p :> p) -> Maybe ((p :> p))) -> (p :> p) -> Maybe Doc
- Darcs.Patch.Properties: identityCommutes :: (Patchy p) => p -> Maybe Doc
+ Darcs.Patch.Properties: identityCommutes :: Patchy p => p -> Maybe Doc
- Darcs.Patch.Properties: inverseDoesntCommute :: (Patchy p) => p -> Maybe Doc
+ Darcs.Patch.Properties: inverseDoesntCommute :: Patchy p => p -> Maybe Doc
- Darcs.Patch.Properties: mergeArgumentsConsistent :: (Patchy p) => (p -> Maybe Doc) -> (p :\/: p) -> Maybe Doc
+ Darcs.Patch.Properties: mergeArgumentsConsistent :: Patchy p => (p -> Maybe Doc) -> (p :\/: p) -> Maybe Doc
- Darcs.Patch.Properties: mergeCommute :: (Patchy p) => (p :\/: p) -> Maybe Doc
+ Darcs.Patch.Properties: mergeCommute :: Patchy p => (p :\/: p) -> Maybe Doc
- Darcs.Patch.Properties: mergeConsistent :: (Patchy p) => (p -> Maybe Doc) -> (p :\/: p) -> Maybe Doc
+ Darcs.Patch.Properties: mergeConsistent :: Patchy p => (p -> Maybe Doc) -> (p :\/: p) -> Maybe Doc
- Darcs.Patch.Properties: mergeEitherWay :: (Patchy p) => (p :\/: p) -> Maybe Doc
+ Darcs.Patch.Properties: mergeEitherWay :: Patchy p => (p :\/: p) -> Maybe Doc
- Darcs.Patch.Properties: partialPermutivity :: (Patchy p) => ((p :> p) -> Maybe ((p :> p))) -> (p :> (p :> p)) -> Maybe Doc
+ Darcs.Patch.Properties: partialPermutivity :: Patchy p => ((p :> p) -> Maybe ((p :> p))) -> (p :> (p :> p)) -> Maybe Doc
- Darcs.Patch.Properties: patchAndInverseCommute :: (Patchy p) => ((p :> p) -> Maybe ((p :> p))) -> (p :> p) -> Maybe Doc
+ Darcs.Patch.Properties: patchAndInverseCommute :: Patchy p => ((p :> p) -> Maybe ((p :> p))) -> (p :> p) -> Maybe Doc
- Darcs.Patch.Properties: permutivity :: (Patchy p) => ((p :> p) -> Maybe ((p :> p))) -> (p :> (p :> p)) -> Maybe Doc
+ Darcs.Patch.Properties: permutivity :: Patchy p => ((p :> p) -> Maybe ((p :> p))) -> (p :> (p :> p)) -> Maybe Doc
- Darcs.Patch.Properties: recommute :: (Patchy p) => (((p :> p) -> Maybe ((p :> p)))) -> (p :> p) -> Maybe Doc
+ Darcs.Patch.Properties: recommute :: Patchy p => (((p :> p) -> Maybe ((p :> p)))) -> (p :> p) -> Maybe Doc
- Darcs.Patch.Read: readPatch :: (ReadPatch p) => ByteString -> Maybe (Sealed (p), ByteString)
+ Darcs.Patch.Read: readPatch :: ReadPatch p => ByteString -> Maybe (Sealed (p), ByteString)
- Darcs.Patch.Read: readPrim :: (ParserM m) => FileNameFormat -> m (Maybe (Sealed (Prim)))
+ Darcs.Patch.Read: readPrim :: ParserM m => FileNameFormat -> m (Maybe (Sealed (Prim)))
- Darcs.Patch.ReadMonads: alterInput :: (ParserM m) => (ByteString -> ByteString) -> m ()
+ Darcs.Patch.ReadMonads: alterInput :: ParserM m => (ByteString -> ByteString) -> m ()
- Darcs.Patch.ReadMonads: class (Monad m) => ParserM m
+ Darcs.Patch.ReadMonads: class Monad m => ParserM m
- Darcs.Patch.ReadMonads: lexChar :: (ParserM m) => Char -> m ()
+ Darcs.Patch.ReadMonads: lexChar :: ParserM m => Char -> m ()
- Darcs.Patch.ReadMonads: lexEof :: (ParserM m) => m ()
+ Darcs.Patch.ReadMonads: lexEof :: ParserM m => m ()
- Darcs.Patch.ReadMonads: lexString :: (ParserM m) => String -> m ()
+ Darcs.Patch.ReadMonads: lexString :: ParserM m => String -> m ()
- Darcs.Patch.ReadMonads: lexStrings :: (ParserM m) => [String] -> m String
+ Darcs.Patch.ReadMonads: lexStrings :: ParserM m => [String] -> m String
- Darcs.Patch.ReadMonads: maybeWork :: (ParserM m) => (ByteString -> Maybe (a, ByteString)) -> m (Maybe a)
+ Darcs.Patch.ReadMonads: maybeWork :: ParserM m => (ByteString -> Maybe (a, ByteString)) -> m (Maybe a)
- Darcs.Patch.ReadMonads: peekInput :: (ParserM m) => m ByteString
+ Darcs.Patch.ReadMonads: peekInput :: ParserM m => m ByteString
- Darcs.Patch.ReadMonads: work :: (ParserM m) => (ByteString -> Maybe (a, ByteString)) -> m a
+ Darcs.Patch.ReadMonads: work :: ParserM m => (ByteString -> Maybe (a, ByteString)) -> m a
- Darcs.Patch.Real: pullCommon :: (Patchy p) => FL p -> FL p -> Common p
+ Darcs.Patch.Real: pullCommon :: Patchy p => FL p -> FL p -> Common p
- Darcs.Patch.TouchesFiles: choosePreTouching :: (Patchy p) => [FilePath] -> FL p -> Sealed (FL p)
+ Darcs.Patch.TouchesFiles: choosePreTouching :: Patchy p => [FilePath] -> FL p -> Sealed (FL p)
- Darcs.Patch.TouchesFiles: chooseTouching :: (Patchy p) => [FilePath] -> FL p -> Sealed (FL p)
+ Darcs.Patch.TouchesFiles: chooseTouching :: Patchy p => [FilePath] -> FL p -> Sealed (FL p)
- Darcs.Patch.TouchesFiles: deselectNotTouching :: (Patchy p) => [FilePath] -> PatchChoices p -> PatchChoices p
+ Darcs.Patch.TouchesFiles: deselectNotTouching :: Patchy p => [FilePath] -> PatchChoices p -> PatchChoices p
- Darcs.Patch.TouchesFiles: lookTouch :: (Patchy p) => [FilePath] -> p -> (Bool, [FilePath])
+ Darcs.Patch.TouchesFiles: lookTouch :: Patchy p => [FilePath] -> p -> (Bool, [FilePath])
- Darcs.Patch.TouchesFiles: selectNotTouching :: (Patchy p) => [FilePath] -> PatchChoices p -> PatchChoices p
+ Darcs.Patch.TouchesFiles: selectNotTouching :: Patchy p => [FilePath] -> PatchChoices p -> PatchChoices p
- Darcs.Patch.TouchesFiles: selectTouching :: (Patchy p) => [FilePath] -> PatchChoices p -> PatchChoices p
+ Darcs.Patch.TouchesFiles: selectTouching :: Patchy p => [FilePath] -> PatchChoices p -> PatchChoices p
- Darcs.PrintPatch: contextualPrintPatch :: (Patchy p) => Tree IO -> p -> IO ()
+ Darcs.PrintPatch: contextualPrintPatch :: Patchy p => Tree IO -> p -> IO ()
- Darcs.PrintPatch: printFriendly :: (Patchy p) => [DarcsFlag] -> p -> IO ()
+ Darcs.PrintPatch: printFriendly :: Patchy p => [DarcsFlag] -> p -> IO ()
- Darcs.PrintPatch: printPatch :: (Patchy p) => p -> IO ()
+ Darcs.PrintPatch: printPatch :: Patchy p => p -> IO ()
- Darcs.PrintPatch: printPatchPager :: (Patchy p) => p -> IO ()
+ Darcs.PrintPatch: printPatchPager :: Patchy p => p -> IO ()
- Darcs.RepoPath: class (FilePathOrURL a) => FilePathLike a
+ Darcs.RepoPath: class FilePathOrURL a => FilePathLike a
- Darcs.RepoPath: setCurrentDirectory :: (FilePathLike p) => p -> IO ()
+ Darcs.RepoPath: setCurrentDirectory :: FilePathLike p => p -> IO ()
- Darcs.RepoPath: toFilePath :: (FilePathLike a) => a -> FilePath
+ Darcs.RepoPath: toFilePath :: FilePathLike a => a -> FilePath
- Darcs.RepoPath: toPath :: (FilePathOrURL a) => a -> String
+ Darcs.RepoPath: toPath :: FilePathOrURL a => a -> String
- Darcs.Repository: ($-) :: ((forall p. (RepoPatch p) => Repository p -> IO a) -> IO a) -> (forall p. (RepoPatch p) => Repository p -> IO a) -> IO a
+ Darcs.Repository: ($-) :: ((forall p. RepoPatch p => Repository p -> IO a) -> IO a) -> (forall p. RepoPatch p => Repository p -> IO a) -> IO a
- Darcs.Repository: addToPending :: (RepoPatch p) => Repository p -> FL Prim -> IO ()
+ Darcs.Repository: addToPending :: RepoPatch p => Repository p -> FL Prim -> IO ()
- Darcs.Repository: applyToWorking :: (Patchy p) => Repository p1 -> [DarcsFlag] -> p -> IO (Repository p1)
+ Darcs.Repository: applyToWorking :: Patchy p => Repository p1 -> [DarcsFlag] -> p -> IO (Repository p1)
- Darcs.Repository: checkUnrelatedRepos :: (RepoPatch p) => [DarcsFlag] -> PatchSet p -> PatchSet p -> IO ()
+ Darcs.Repository: checkUnrelatedRepos :: RepoPatch p => [DarcsFlag] -> PatchSet p -> PatchSet p -> IO ()
- Darcs.Repository: cleanRepository :: (RepoPatch p) => Repository p -> IO ()
+ Darcs.Repository: cleanRepository :: RepoPatch p => Repository p -> IO ()
- Darcs.Repository: considerMergeToWorking :: (RepoPatch p) => Repository p -> String -> [DarcsFlag] -> FL (PatchInfoAnd p) -> FL (PatchInfoAnd p) -> IO (Sealed (FL Prim))
+ Darcs.Repository: considerMergeToWorking :: RepoPatch p => Repository p -> String -> [DarcsFlag] -> FL (PatchInfoAnd p) -> FL (PatchInfoAnd p) -> IO (Sealed (FL Prim))
- Darcs.Repository: copyOldrepoPatches :: (RepoPatch p) => [DarcsFlag] -> Repository p -> FilePath -> IO ()
+ Darcs.Repository: copyOldrepoPatches :: RepoPatch p => [DarcsFlag] -> Repository p -> FilePath -> IO ()
- Darcs.Repository: copyRepository :: (RepoPatch p) => Repository p -> IO ()
+ Darcs.Repository: copyRepository :: RepoPatch p => Repository p -> IO ()
- Darcs.Repository: createPristineDirectoryTree :: (RepoPatch p) => Repository p -> FilePath -> IO ()
+ Darcs.Repository: createPristineDirectoryTree :: RepoPatch p => Repository p -> FilePath -> IO ()
- Darcs.Repository: data Repository p
+ Darcs.Repository: data Repository p :: *
- Darcs.Repository: finalizeRepositoryChanges :: (RepoPatch p) => Repository p -> IO ()
+ Darcs.Repository: finalizeRepositoryChanges :: RepoPatch p => Repository p -> IO ()
- Darcs.Repository: getMarkedupFile :: (RepoPatch p) => Repository p -> PatchInfo -> FilePath -> IO MarkedUpFile
+ Darcs.Repository: getMarkedupFile :: RepoPatch p => Repository p -> PatchInfo -> FilePath -> IO MarkedUpFile
- Darcs.Repository: identifyRepositoryFor :: (RepoPatch p) => Repository p -> String -> IO (Repository p)
+ Darcs.Repository: identifyRepositoryFor :: RepoPatch p => Repository p -> String -> IO (Repository p)
- Darcs.Repository: makePatchLazy :: (RepoPatch p) => Repository p -> PatchInfoAnd p -> IO (PatchInfoAnd p)
+ Darcs.Repository: makePatchLazy :: RepoPatch p => Repository p -> PatchInfoAnd p -> IO (PatchInfoAnd p)
- Darcs.Repository: modifyCache :: (RepoPatch p) => Repository p -> (Cache -> Cache) -> Repository p
+ Darcs.Repository: modifyCache :: RepoPatch p => Repository p -> (Cache -> Cache) -> Repository p
- Darcs.Repository: optimizeInventory :: (RepoPatch p) => Repository p -> IO ()
+ Darcs.Repository: optimizeInventory :: RepoPatch p => Repository p -> IO ()
- Darcs.Repository: patchSetToPatches :: (RepoPatch p) => PatchSet p -> FL (Named p)
+ Darcs.Repository: patchSetToPatches :: RepoPatch p => PatchSet p -> FL (Named p)
- Darcs.Repository: patchSetToRepository :: (RepoPatch p) => Repository p -> PatchSet p -> [DarcsFlag] -> IO (Repository p)
+ Darcs.Repository: patchSetToRepository :: RepoPatch p => Repository p -> PatchSet p -> [DarcsFlag] -> IO (Repository p)
- Darcs.Repository: readIndex :: (RepoPatch p) => Repository p -> IO Index
+ Darcs.Repository: readIndex :: RepoPatch p => Repository p -> IO Index
- Darcs.Repository: readPending :: (RepoPatch p) => Repository p -> IO (Tree IO, Sealed (FL Prim))
+ Darcs.Repository: readPending :: RepoPatch p => Repository p -> IO (Tree IO, Sealed (FL Prim))
- Darcs.Repository: readRecorded :: (RepoPatch p) => Repository p -> IO (Tree IO)
+ Darcs.Repository: readRecorded :: RepoPatch p => Repository p -> IO (Tree IO)
- Darcs.Repository: readRecordedAndPending :: (RepoPatch p) => Repository p -> IO (Tree IO)
+ Darcs.Repository: readRecordedAndPending :: RepoPatch p => Repository p -> IO (Tree IO)
- Darcs.Repository: readRepo :: (RepoPatch p) => Repository p -> IO (PatchSet p)
+ Darcs.Repository: readRepo :: RepoPatch p => Repository p -> IO (PatchSet p)
- Darcs.Repository: readTentativeRepo :: (RepoPatch p) => Repository p -> IO (PatchSet p)
+ Darcs.Repository: readTentativeRepo :: RepoPatch p => Repository p -> IO (PatchSet p)
- Darcs.Repository: readUnrecorded :: (RepoPatch p) => Repository p -> [SubPath] -> IO (Tree IO)
+ Darcs.Repository: readUnrecorded :: RepoPatch p => Repository p -> [SubPath] -> IO (Tree IO)
- Darcs.Repository: revertRepositoryChanges :: (RepoPatch p) => Repository p -> IO ()
+ Darcs.Repository: revertRepositoryChanges :: RepoPatch p => Repository p -> IO ()
- Darcs.Repository: tentativelyAddPatch :: (RepoPatch p) => Repository p -> [DarcsFlag] -> PatchInfoAnd p -> IO (Repository p)
+ Darcs.Repository: tentativelyAddPatch :: RepoPatch p => Repository p -> [DarcsFlag] -> PatchInfoAnd p -> IO (Repository p)
- Darcs.Repository: tentativelyAddToPending :: (RepoPatch p) => Repository p -> [DarcsFlag] -> FL Prim -> IO ()
+ Darcs.Repository: tentativelyAddToPending :: RepoPatch p => Repository p -> [DarcsFlag] -> FL Prim -> IO ()
- Darcs.Repository: tentativelyMergePatches :: (RepoPatch p) => Repository p -> String -> [DarcsFlag] -> FL (PatchInfoAnd p) -> FL (PatchInfoAnd p) -> IO (Sealed (FL Prim))
+ Darcs.Repository: tentativelyMergePatches :: RepoPatch p => Repository p -> String -> [DarcsFlag] -> FL (PatchInfoAnd p) -> FL (PatchInfoAnd p) -> IO (Sealed (FL Prim))
- Darcs.Repository: tentativelyRemovePatches :: (RepoPatch p) => Repository p -> [DarcsFlag] -> FL (PatchInfoAnd p) -> IO (Repository p)
+ Darcs.Repository: tentativelyRemovePatches :: RepoPatch p => Repository p -> [DarcsFlag] -> FL (PatchInfoAnd p) -> IO (Repository p)
- Darcs.Repository: tentativelyReplacePatches :: (RepoPatch p) => Repository p -> [DarcsFlag] -> FL (PatchInfoAnd p) -> IO (Repository p)
+ Darcs.Repository: tentativelyReplacePatches :: RepoPatch p => Repository p -> [DarcsFlag] -> FL (PatchInfoAnd p) -> IO (Repository p)
- Darcs.Repository: testRecorded :: (RepoPatch p) => Repository p -> IO ()
+ Darcs.Repository: testRecorded :: RepoPatch p => Repository p -> IO ()
- Darcs.Repository: testTentative :: (RepoPatch p) => Repository p -> IO ()
+ Darcs.Repository: testTentative :: RepoPatch p => Repository p -> IO ()
- Darcs.Repository: unrecordedChanges :: (RepoPatch p) => [DarcsFlag] -> Repository p -> [SubPath] -> IO (FL Prim)
+ Darcs.Repository: unrecordedChanges :: RepoPatch p => [DarcsFlag] -> Repository p -> [SubPath] -> IO (FL Prim)
- Darcs.Repository: withRecorded :: (RepoPatch p) => Repository p -> ((AbsolutePath -> IO a) -> IO a) -> (AbsolutePath -> IO a) -> IO a
+ Darcs.Repository: withRecorded :: RepoPatch p => Repository p -> ((AbsolutePath -> IO a) -> IO a) -> (AbsolutePath -> IO a) -> IO a
- Darcs.Repository: withRepoLock :: [DarcsFlag] -> (forall p. (RepoPatch p) => Repository p -> IO a) -> IO a
+ Darcs.Repository: withRepoLock :: [DarcsFlag] -> (forall p. RepoPatch p => Repository p -> IO a) -> IO a
- Darcs.Repository: withRepoReadLock :: [DarcsFlag] -> (forall p. (RepoPatch p) => Repository p -> IO a) -> IO a
+ Darcs.Repository: withRepoReadLock :: [DarcsFlag] -> (forall p. RepoPatch p => Repository p -> IO a) -> IO a
- Darcs.Repository: withRepository :: [DarcsFlag] -> (forall p. (RepoPatch p) => Repository p -> IO a) -> IO a
+ Darcs.Repository: withRepository :: [DarcsFlag] -> (forall p. RepoPatch p => Repository p -> IO a) -> IO a
- Darcs.Repository: withRepositoryDirectory :: [DarcsFlag] -> String -> (forall p. (RepoPatch p) => Repository p -> IO a) -> IO a
+ Darcs.Repository: withRepositoryDirectory :: [DarcsFlag] -> String -> (forall p. RepoPatch p => Repository p -> IO a) -> IO a
- Darcs.Repository: writePatchSet :: (RepoPatch p) => PatchSet p -> [DarcsFlag] -> IO (Repository p)
+ Darcs.Repository: writePatchSet :: RepoPatch p => PatchSet p -> [DarcsFlag] -> IO (Repository p)
- Darcs.Repository.ApplyPatches: applyPatches :: (Patchy p) => [DarcsFlag] -> FL (PatchInfoAnd p) -> IO ()
+ Darcs.Repository.ApplyPatches: applyPatches :: Patchy p => [DarcsFlag] -> FL (PatchInfoAnd p) -> IO ()
- Darcs.Repository.ApplyPatches: applyPatchesWithFeedback :: (Patchy p) => [DarcsFlag] -> String -> FL (PatchInfoAnd p) -> IO ()
+ Darcs.Repository.ApplyPatches: applyPatchesWithFeedback :: Patchy p => [DarcsFlag] -> String -> FL (PatchInfoAnd p) -> IO ()
- Darcs.Repository.Checkpoint: getCheckpoint :: (RepoPatch p) => Repository p -> IO (Maybe (Sealed (Named p)))
+ Darcs.Repository.Checkpoint: getCheckpoint :: RepoPatch p => Repository p -> IO (Maybe (Sealed (Named p)))
- Darcs.Repository.Checkpoint: getCheckpointByDefault :: (RepoPatch p) => Repository p -> IO (Maybe (Sealed (Named p)))
+ Darcs.Repository.Checkpoint: getCheckpointByDefault :: RepoPatch p => Repository p -> IO (Maybe (Sealed (Named p)))
- Darcs.Repository.Checkpoint: identifyCheckpoint :: (RepoPatch p) => Repository p -> IO (Maybe PatchInfo)
+ Darcs.Repository.Checkpoint: identifyCheckpoint :: RepoPatch p => Repository p -> IO (Maybe PatchInfo)
- Darcs.Repository.Checkpoint: writeCheckpointPatch :: (RepoPatch p) => Named p -> IO ()
+ Darcs.Repository.Checkpoint: writeCheckpointPatch :: RepoPatch p => Named p -> IO ()
- Darcs.Repository.DarcsRepo: addToTentativeInventory :: (RepoPatch p) => [DarcsFlag] -> Named p -> IO FilePath
+ Darcs.Repository.DarcsRepo: addToTentativeInventory :: RepoPatch p => [DarcsFlag] -> Named p -> IO FilePath
- Darcs.Repository.DarcsRepo: addToTentativePristine :: (Effect p) => p -> IO ()
+ Darcs.Repository.DarcsRepo: addToTentativePristine :: Effect p => p -> IO ()
- Darcs.Repository.DarcsRepo: readRepo :: (RepoPatch p) => [DarcsFlag] -> String -> IO (SealedPatchSet p)
+ Darcs.Repository.DarcsRepo: readRepo :: RepoPatch p => [DarcsFlag] -> String -> IO (SealedPatchSet p)
- Darcs.Repository.DarcsRepo: readTentativeRepo :: (RepoPatch p) => [DarcsFlag] -> String -> IO (SealedPatchSet p)
+ Darcs.Repository.DarcsRepo: readTentativeRepo :: RepoPatch p => [DarcsFlag] -> String -> IO (SealedPatchSet p)
- Darcs.Repository.DarcsRepo: removeFromTentativeInventory :: (RepoPatch p) => Bool -> [DarcsFlag] -> FL (PatchInfoAnd p) -> IO ()
+ Darcs.Repository.DarcsRepo: removeFromTentativeInventory :: RepoPatch p => Bool -> [DarcsFlag] -> FL (PatchInfoAnd p) -> IO ()
- Darcs.Repository.DarcsRepo: writeAndReadPatch :: (RepoPatch p) => [DarcsFlag] -> PatchInfoAnd p -> IO (PatchInfoAnd p)
+ Darcs.Repository.DarcsRepo: writeAndReadPatch :: RepoPatch p => [DarcsFlag] -> PatchInfoAnd p -> IO (PatchInfoAnd p)
- Darcs.Repository.DarcsRepo: writeInventory :: (RepoPatch p) => FilePath -> PatchSet p -> IO ()
+ Darcs.Repository.DarcsRepo: writeInventory :: RepoPatch p => FilePath -> PatchSet p -> IO ()
- Darcs.Repository.DarcsRepo: writeInventoryAndPatches :: (RepoPatch p) => [DarcsFlag] -> PatchSet p -> IO ()
+ Darcs.Repository.DarcsRepo: writeInventoryAndPatches :: RepoPatch p => [DarcsFlag] -> PatchSet p -> IO ()
- Darcs.Repository.HashedIO: copyPartialsHashed :: (FilePathLike fp) => Cache -> Compression -> String -> [fp] -> IO ()
+ Darcs.Repository.HashedIO: copyPartialsHashed :: FilePathLike fp => Cache -> Compression -> String -> [fp] -> IO ()
- Darcs.Repository.HashedRepo: addToTentativeInventory :: (RepoPatch p) => Cache -> Compression -> PatchInfoAnd p -> IO FilePath
+ Darcs.Repository.HashedRepo: addToTentativeInventory :: RepoPatch p => Cache -> Compression -> PatchInfoAnd p -> IO FilePath
- Darcs.Repository.HashedRepo: applyToTentativePristine :: (Patchy q) => [DarcsFlag] -> q -> IO ()
+ Darcs.Repository.HashedRepo: applyToTentativePristine :: Patchy q => [DarcsFlag] -> q -> IO ()
- Darcs.Repository.HashedRepo: copyPartialsPristine :: (FilePathLike fp) => Cache -> Compression -> String -> String -> [fp] -> IO ()
+ Darcs.Repository.HashedRepo: copyPartialsPristine :: FilePathLike fp => Cache -> Compression -> String -> String -> [fp] -> IO ()
- Darcs.Repository.HashedRepo: copyRepo :: (RepoPatch p) => Repository p -> [DarcsFlag] -> String -> IO ()
+ Darcs.Repository.HashedRepo: copyRepo :: RepoPatch p => Repository p -> [DarcsFlag] -> String -> IO ()
- Darcs.Repository.HashedRepo: copySources :: (RepoPatch p) => Repository p -> String -> IO ()
+ Darcs.Repository.HashedRepo: copySources :: RepoPatch p => Repository p -> String -> IO ()
- Darcs.Repository.HashedRepo: finalizeTentativeChanges :: (RepoPatch p) => Repository p -> Compression -> IO ()
+ Darcs.Repository.HashedRepo: finalizeTentativeChanges :: RepoPatch p => Repository p -> Compression -> IO ()
- Darcs.Repository.HashedRepo: readRepo :: (RepoPatch p) => Repository p -> String -> IO (PatchSet p)
+ Darcs.Repository.HashedRepo: readRepo :: RepoPatch p => Repository p -> String -> IO (PatchSet p)
- Darcs.Repository.HashedRepo: readTentativeRepo :: (RepoPatch p) => Repository p -> String -> IO (PatchSet p)
+ Darcs.Repository.HashedRepo: readTentativeRepo :: RepoPatch p => Repository p -> String -> IO (PatchSet p)
- Darcs.Repository.HashedRepo: removeFromTentativeInventory :: (RepoPatch p) => Repository p -> Compression -> FL (PatchInfoAnd p) -> IO ()
+ Darcs.Repository.HashedRepo: removeFromTentativeInventory :: RepoPatch p => Repository p -> Compression -> FL (PatchInfoAnd p) -> IO ()
- Darcs.Repository.HashedRepo: writeAndReadPatch :: (RepoPatch p) => Cache -> Compression -> PatchInfoAnd p -> IO (PatchInfoAnd p)
+ Darcs.Repository.HashedRepo: writeAndReadPatch :: RepoPatch p => Cache -> Compression -> PatchInfoAnd p -> IO (PatchInfoAnd p)
- Darcs.Repository.HashedRepo: writeTentativeInventory :: (RepoPatch p) => Cache -> Compression -> PatchSet p -> IO ()
+ Darcs.Repository.HashedRepo: writeTentativeInventory :: RepoPatch p => Cache -> Compression -> PatchSet p -> IO ()
- Darcs.Repository.Internal: ($-) :: ((forall p. (RepoPatch p) => Repository p -> IO a) -> IO a) -> (forall p. (RepoPatch p) => Repository p -> IO a) -> IO a
+ Darcs.Repository.Internal: ($-) :: ((forall p. RepoPatch p => Repository p -> IO a) -> IO a) -> (forall p. RepoPatch p => Repository p -> IO a) -> IO a
- Darcs.Repository.Internal: applyToWorking :: (Patchy p) => Repository p1 -> [DarcsFlag] -> p -> IO (Repository p1)
+ Darcs.Repository.Internal: applyToWorking :: Patchy p => Repository p1 -> [DarcsFlag] -> p -> IO (Repository p1)
- Darcs.Repository.Internal: checkUnrecordedConflicts :: (RepoPatch p) => [DarcsFlag] -> FL (Named p) -> IO Bool
+ Darcs.Repository.Internal: checkUnrecordedConflicts :: RepoPatch p => [DarcsFlag] -> FL (Named p) -> IO Bool
- Darcs.Repository.Internal: cleanRepository :: (RepoPatch p) => Repository p -> IO ()
+ Darcs.Repository.Internal: cleanRepository :: RepoPatch p => Repository p -> IO ()
- Darcs.Repository.Internal: createPristineDirectoryTree :: (RepoPatch p) => Repository p -> FilePath -> IO ()
+ Darcs.Repository.Internal: createPristineDirectoryTree :: RepoPatch p => Repository p -> FilePath -> IO ()
- Darcs.Repository.Internal: data RepoType p
+ Darcs.Repository.Internal: data RepoType p :: *
- Darcs.Repository.Internal: data Repository p
+ Darcs.Repository.Internal: data Repository p :: *
- Darcs.Repository.Internal: finalizeRepositoryChanges :: (RepoPatch p) => Repository p -> IO ()
+ Darcs.Repository.Internal: finalizeRepositoryChanges :: RepoPatch p => Repository p -> IO ()
- Darcs.Repository.Internal: getMarkedupFile :: (RepoPatch p) => Repository p -> PatchInfo -> FilePath -> IO MarkedUpFile
+ Darcs.Repository.Internal: getMarkedupFile :: RepoPatch p => Repository p -> PatchInfo -> FilePath -> IO MarkedUpFile
- Darcs.Repository.Internal: identifyRepositoryFor :: (RepoPatch p) => Repository p -> String -> IO (Repository p)
+ Darcs.Repository.Internal: identifyRepositoryFor :: RepoPatch p => Repository p -> String -> IO (Repository p)
- Darcs.Repository.Internal: makeNewPending :: (RepoPatch p) => Repository p -> FL Prim -> IO ()
+ Darcs.Repository.Internal: makeNewPending :: RepoPatch p => Repository p -> FL Prim -> IO ()
- Darcs.Repository.Internal: makePatchLazy :: (RepoPatch p) => Repository p -> PatchInfoAnd p -> IO (PatchInfoAnd p)
+ Darcs.Repository.Internal: makePatchLazy :: RepoPatch p => Repository p -> PatchInfoAnd p -> IO (PatchInfoAnd p)
- Darcs.Repository.Internal: optimizeInventory :: (RepoPatch p) => Repository p -> IO ()
+ Darcs.Repository.Internal: optimizeInventory :: RepoPatch p => Repository p -> IO ()
- Darcs.Repository.Internal: patchSetToPatches :: (RepoPatch p) => PatchSet p -> FL (Named p)
+ Darcs.Repository.Internal: patchSetToPatches :: RepoPatch p => PatchSet p -> FL (Named p)
- Darcs.Repository.Internal: readRepo :: (RepoPatch p) => Repository p -> IO (PatchSet p)
+ Darcs.Repository.Internal: readRepo :: RepoPatch p => Repository p -> IO (PatchSet p)
- Darcs.Repository.Internal: readTentativeRepo :: (RepoPatch p) => Repository p -> IO (PatchSet p)
+ Darcs.Repository.Internal: readTentativeRepo :: RepoPatch p => Repository p -> IO (PatchSet p)
- Darcs.Repository.Internal: revertRepositoryChanges :: (RepoPatch p) => Repository p -> IO ()
+ Darcs.Repository.Internal: revertRepositoryChanges :: RepoPatch p => Repository p -> IO ()
- Darcs.Repository.Internal: setTentativePending :: (RepoPatch p) => Repository p -> FL Prim -> IO ()
+ Darcs.Repository.Internal: setTentativePending :: RepoPatch p => Repository p -> FL Prim -> IO ()
- Darcs.Repository.Internal: tentativelyAddPatch :: (RepoPatch p) => Repository p -> [DarcsFlag] -> PatchInfoAnd p -> IO (Repository p)
+ Darcs.Repository.Internal: tentativelyAddPatch :: RepoPatch p => Repository p -> [DarcsFlag] -> PatchInfoAnd p -> IO (Repository p)
- Darcs.Repository.Internal: tentativelyAddPatch_ :: (RepoPatch p) => UpdatePristine -> Repository p -> [DarcsFlag] -> PatchInfoAnd p -> IO (Repository p)
+ Darcs.Repository.Internal: tentativelyAddPatch_ :: RepoPatch p => UpdatePristine -> Repository p -> [DarcsFlag] -> PatchInfoAnd p -> IO (Repository p)
- Darcs.Repository.Internal: tentativelyAddToPending :: (RepoPatch p) => Repository p -> [DarcsFlag] -> FL Prim -> IO ()
+ Darcs.Repository.Internal: tentativelyAddToPending :: RepoPatch p => Repository p -> [DarcsFlag] -> FL Prim -> IO ()
- Darcs.Repository.Internal: tentativelyRemovePatches :: (RepoPatch p) => Repository p -> [DarcsFlag] -> FL (PatchInfoAnd p) -> IO (Repository p)
+ Darcs.Repository.Internal: tentativelyRemovePatches :: RepoPatch p => Repository p -> [DarcsFlag] -> FL (PatchInfoAnd p) -> IO (Repository p)
- Darcs.Repository.Internal: tentativelyReplacePatches :: (RepoPatch p) => Repository p -> [DarcsFlag] -> FL (PatchInfoAnd p) -> IO (Repository p)
+ Darcs.Repository.Internal: tentativelyReplacePatches :: RepoPatch p => Repository p -> [DarcsFlag] -> FL (PatchInfoAnd p) -> IO (Repository p)
- Darcs.Repository.Internal: testRecorded :: (RepoPatch p) => Repository p -> IO ()
+ Darcs.Repository.Internal: testRecorded :: RepoPatch p => Repository p -> IO ()
- Darcs.Repository.Internal: testTentative :: (RepoPatch p) => Repository p -> IO ()
+ Darcs.Repository.Internal: testTentative :: RepoPatch p => Repository p -> IO ()
- Darcs.Repository.Internal: withRecorded :: (RepoPatch p) => Repository p -> ((AbsolutePath -> IO a) -> IO a) -> (AbsolutePath -> IO a) -> IO a
+ Darcs.Repository.Internal: withRecorded :: RepoPatch p => Repository p -> ((AbsolutePath -> IO a) -> IO a) -> (AbsolutePath -> IO a) -> IO a
- Darcs.Repository.Internal: withRepoLock :: [DarcsFlag] -> (forall p. (RepoPatch p) => Repository p -> IO a) -> IO a
+ Darcs.Repository.Internal: withRepoLock :: [DarcsFlag] -> (forall p. RepoPatch p => Repository p -> IO a) -> IO a
- Darcs.Repository.Internal: withRepoReadLock :: [DarcsFlag] -> (forall p. (RepoPatch p) => Repository p -> IO a) -> IO a
+ Darcs.Repository.Internal: withRepoReadLock :: [DarcsFlag] -> (forall p. RepoPatch p => Repository p -> IO a) -> IO a
- Darcs.Repository.Internal: withRepository :: [DarcsFlag] -> (forall p. (RepoPatch p) => Repository p -> IO a) -> IO a
+ Darcs.Repository.Internal: withRepository :: [DarcsFlag] -> (forall p. RepoPatch p => Repository p -> IO a) -> IO a
- Darcs.Repository.Internal: withRepositoryDirectory :: [DarcsFlag] -> String -> (forall p. (RepoPatch p) => Repository p -> IO a) -> IO a
+ Darcs.Repository.Internal: withRepositoryDirectory :: [DarcsFlag] -> String -> (forall p. RepoPatch p => Repository p -> IO a) -> IO a
- Darcs.Repository.InternalTypes: data RepoType p
+ Darcs.Repository.InternalTypes: data RepoType p :: *
- Darcs.Repository.InternalTypes: data Repository p
+ Darcs.Repository.InternalTypes: data Repository p :: *
- Darcs.Repository.InternalTypes: modifyCache :: (RepoPatch p) => Repository p -> (Cache -> Cache) -> Repository p
+ Darcs.Repository.InternalTypes: modifyCache :: RepoPatch p => Repository p -> (Cache -> Cache) -> Repository p
- Darcs.Repository.LowLevel: readPending :: (RepoPatch p) => Repository p -> IO (Sealed (FL Prim))
+ Darcs.Repository.LowLevel: readPending :: RepoPatch p => Repository p -> IO (Sealed (FL Prim))
- Darcs.Repository.Merge: considerMergeToWorking :: (RepoPatch p) => Repository p -> String -> [DarcsFlag] -> FL (PatchInfoAnd p) -> FL (PatchInfoAnd p) -> IO (Sealed (FL Prim))
+ Darcs.Repository.Merge: considerMergeToWorking :: RepoPatch p => Repository p -> String -> [DarcsFlag] -> FL (PatchInfoAnd p) -> FL (PatchInfoAnd p) -> IO (Sealed (FL Prim))
- Darcs.Repository.Merge: tentativelyMergePatches :: (RepoPatch p) => Repository p -> String -> [DarcsFlag] -> FL (PatchInfoAnd p) -> FL (PatchInfoAnd p) -> IO (Sealed (FL Prim))
+ Darcs.Repository.Merge: tentativelyMergePatches :: RepoPatch p => Repository p -> String -> [DarcsFlag] -> FL (PatchInfoAnd p) -> FL (PatchInfoAnd p) -> IO (Sealed (FL Prim))
- Darcs.Repository.Merge: tentativelyMergePatches_ :: (RepoPatch p) => MakeChanges -> Repository p -> String -> [DarcsFlag] -> FL (PatchInfoAnd p) -> FL (PatchInfoAnd p) -> IO (Sealed (FL Prim))
+ Darcs.Repository.Merge: tentativelyMergePatches_ :: RepoPatch p => MakeChanges -> Repository p -> String -> [DarcsFlag] -> FL (PatchInfoAnd p) -> FL (PatchInfoAnd p) -> IO (Sealed (FL Prim))
- Darcs.Repository.Prefs: addToPreflist :: (WriteableDirectory m) => String -> String -> m ()
+ Darcs.Repository.Prefs: addToPreflist :: WriteableDirectory m => String -> String -> m ()
- Darcs.Repository.Prefs: changePrefval :: (WriteableDirectory m) => String -> String -> String -> m ()
+ Darcs.Repository.Prefs: changePrefval :: WriteableDirectory m => String -> String -> String -> m ()
- Darcs.Repository.Prefs: getPreflist :: (ReadableDirectory m) => String -> m [String]
+ Darcs.Repository.Prefs: getPreflist :: ReadableDirectory m => String -> m [String]
- Darcs.Repository.Prefs: getPrefval :: (ReadableDirectory m) => String -> m (Maybe String)
+ Darcs.Repository.Prefs: getPrefval :: ReadableDirectory m => String -> m (Maybe String)
- Darcs.Repository.Prefs: setPreflist :: (WriteableDirectory m) => String -> [String] -> m ()
+ Darcs.Repository.Prefs: setPreflist :: WriteableDirectory m => String -> [String] -> m ()
- Darcs.Repository.Prefs: setPrefval :: (WriteableDirectory m) => String -> String -> m ()
+ Darcs.Repository.Prefs: setPrefval :: WriteableDirectory m => String -> String -> m ()
- Darcs.Repository.Pristine: applyPristine :: (Patchy p) => Pristine -> p -> IO ()
+ Darcs.Repository.Pristine: applyPristine :: Patchy p => Pristine -> p -> IO ()
- Darcs.Repository.Pristine: easyCreatePartialsPristineDirectoryTree :: (FilePathLike fp) => [fp] -> Pristine -> FilePath -> IO Bool
+ Darcs.Repository.Pristine: easyCreatePartialsPristineDirectoryTree :: FilePathLike fp => [fp] -> Pristine -> FilePath -> IO Bool
- Darcs.Repository.Repair: checkIndex :: (RepoPatch p) => Repository p -> Bool -> IO Bool
+ Darcs.Repository.Repair: checkIndex :: RepoPatch p => Repository p -> Bool -> IO Bool
- Darcs.Repository.Repair: replayRepository :: (RepoPatch p) => Repository p -> [DarcsFlag] -> (RepositoryConsistency p -> IO a) -> IO a
+ Darcs.Repository.Repair: replayRepository :: RepoPatch p => Repository p -> [DarcsFlag] -> (RepositoryConsistency p -> IO a) -> IO a
- Darcs.Repository.State: TreeFilter :: (forall tr. (FilterTree tr m) => tr m -> tr m) -> TreeFilter m
+ Darcs.Repository.State: TreeFilter :: (forall tr. FilterTree tr m => tr m -> tr m) -> TreeFilter m
- Darcs.Repository.State: applyTreeFilter :: TreeFilter m -> forall tr. (FilterTree tr m) => tr m -> tr m
+ Darcs.Repository.State: applyTreeFilter :: TreeFilter m -> forall tr. FilterTree tr m => tr m -> tr m
- Darcs.Repository.State: readIndex :: (RepoPatch p) => Repository p -> IO Index
+ Darcs.Repository.State: readIndex :: RepoPatch p => Repository p -> IO Index
- Darcs.Repository.State: readPending :: (RepoPatch p) => Repository p -> IO (Tree IO, Sealed (FL Prim))
+ Darcs.Repository.State: readPending :: RepoPatch p => Repository p -> IO (Tree IO, Sealed (FL Prim))
- Darcs.Repository.State: readRecorded :: (RepoPatch p) => Repository p -> IO (Tree IO)
+ Darcs.Repository.State: readRecorded :: RepoPatch p => Repository p -> IO (Tree IO)
- Darcs.Repository.State: readRecordedAndPending :: (RepoPatch p) => Repository p -> IO (Tree IO)
+ Darcs.Repository.State: readRecordedAndPending :: RepoPatch p => Repository p -> IO (Tree IO)
- Darcs.Repository.State: readUnrecorded :: (RepoPatch p) => Repository p -> [SubPath] -> IO (Tree IO)
+ Darcs.Repository.State: readUnrecorded :: RepoPatch p => Repository p -> [SubPath] -> IO (Tree IO)
- Darcs.Repository.State: restrictSubpaths :: (RepoPatch p) => Repository p -> [SubPath] -> IO (TreeFilter m)
+ Darcs.Repository.State: restrictSubpaths :: RepoPatch p => Repository p -> [SubPath] -> IO (TreeFilter m)
- Darcs.Repository.State: unrecordedChanges :: (RepoPatch p) => [DarcsFlag] -> Repository p -> [SubPath] -> IO (FL Prim)
+ Darcs.Repository.State: unrecordedChanges :: RepoPatch p => [DarcsFlag] -> Repository p -> [SubPath] -> IO (FL Prim)
- Darcs.Resolution: externalResolution :: (RepoPatch p) => Tree IO -> String -> FL Prim -> FL Prim -> p -> IO (Sealed (FL Prim))
+ Darcs.Resolution: externalResolution :: RepoPatch p => Tree IO -> String -> FL Prim -> FL Prim -> p -> IO (Sealed (FL Prim))
- Darcs.Resolution: patchsetConflictResolutions :: (RepoPatch p) => PatchSet p -> Sealed (FL Prim)
+ Darcs.Resolution: patchsetConflictResolutions :: RepoPatch p => PatchSet p -> Sealed (FL Prim)
- Darcs.Resolution: standardResolution :: (RepoPatch p) => p -> Sealed (FL Prim)
+ Darcs.Resolution: standardResolution :: RepoPatch p => p -> Sealed (FL Prim)
- Darcs.SelectChanges: filterOutConflicts :: (RepoPatch p) => [DarcsFlag] -> RL (PatchInfoAnd p) -> Repository p -> FL (PatchInfoAnd p) -> IO (Bool, Sealed (FL (PatchInfoAnd p)))
+ Darcs.SelectChanges: filterOutConflicts :: RepoPatch p => [DarcsFlag] -> RL (PatchInfoAnd p) -> Repository p -> FL (PatchInfoAnd p) -> IO (Bool, Sealed (FL (PatchInfoAnd p)))
- Darcs.SelectChanges: runSelection :: (Patchy p) => PatchSelection p -> PatchSelectionContext p -> IO ((FL p :> FL p))
+ Darcs.SelectChanges: runSelection :: Patchy p => PatchSelection p -> PatchSelectionContext p -> IO ((FL p :> FL p))
- Darcs.SelectChanges: selectChanges :: (Patchy p) => WhichChanges -> FL p -> PatchSelection p
+ Darcs.SelectChanges: selectChanges :: Patchy p => WhichChanges -> FL p -> PatchSelection p
- Darcs.SelectChanges: selectionContext :: (RepoPatch p) => String -> [DarcsFlag] -> Maybe (Splitter (PatchInfoAnd p)) -> [FilePath] -> PatchSelectionContext (PatchInfoAnd p)
+ Darcs.SelectChanges: selectionContext :: RepoPatch p => String -> [DarcsFlag] -> Maybe (Splitter (PatchInfoAnd p)) -> [FilePath] -> PatchSelectionContext (PatchInfoAnd p)
- Darcs.SelectChanges: viewChanges :: (Patchy p) => [DarcsFlag] -> [Sealed2 p] -> IO ()
+ Darcs.SelectChanges: viewChanges :: Patchy p => [DarcsFlag] -> [Sealed2 p] -> IO ()
- Darcs.SelectChanges: withSelectedPatchFromRepo :: (RepoPatch p) => String -> Repository p -> [DarcsFlag] -> ((FL (PatchInfoAnd p) :> PatchInfoAnd p) -> IO ()) -> IO ()
+ Darcs.SelectChanges: withSelectedPatchFromRepo :: RepoPatch p => String -> Repository p -> [DarcsFlag] -> ((FL (PatchInfoAnd p) :> PatchInfoAnd p) -> IO ()) -> IO ()
- Darcs.Utils: editFile :: (FilePathLike p) => p -> IO ExitCode
+ Darcs.Utils: editFile :: FilePathLike p => p -> IO ExitCode
- Darcs.Utils: firstJustM :: (Monad m) => [m (Maybe a)] -> m (Maybe a)
+ Darcs.Utils: firstJustM :: Monad m => [m (Maybe a)] -> m (Maybe a)
- Darcs.Utils: nubsort :: (Ord a) => [a] -> [a]
+ Darcs.Utils: nubsort :: Ord a => [a] -> [a]
- Darcs.Utils: showHexLen :: (Integral a) => Int -> a -> String
+ Darcs.Utils: showHexLen :: Integral a => Int -> a -> String
- Darcs.Utils: withCurrentDirectory :: (FilePathLike p) => p -> IO a -> IO a
+ Darcs.Utils: withCurrentDirectory :: FilePathLike p => p -> IO a -> IO a
- Darcs.Witnesses.Ordered: (=/\=) :: (MyEq p) => p -> p -> EqCheck
+ Darcs.Witnesses.Ordered: (=/\=) :: MyEq p => p -> p -> EqCheck
- Darcs.Witnesses.Ordered: (=\/=) :: (MyEq p) => p -> p -> EqCheck
+ Darcs.Witnesses.Ordered: (=\/=) :: MyEq p => p -> p -> EqCheck
- Darcs.Witnesses.Ordered: spanFL_M :: (Monad m) => (a -> m Bool) -> FL a -> m ((FL a :> FL a))
+ Darcs.Witnesses.Ordered: spanFL_M :: Monad m => (a -> m Bool) -> FL a -> m ((FL a :> FL a))
- Darcs.Witnesses.Ordered: unsafeCompare :: (MyEq p) => p -> p -> Bool
+ Darcs.Witnesses.Ordered: unsafeCompare :: MyEq p => p -> p -> Bool
- Darcs.Witnesses.Sealed: emptyGap :: (Gap w) => (p) -> w p
+ Darcs.Witnesses.Sealed: emptyGap :: Gap w => (p) -> w p
- Darcs.Witnesses.Sealed: freeGap :: (Gap w) => (p) -> w p
+ Darcs.Witnesses.Sealed: freeGap :: Gap w => (p) -> w p
- Darcs.Witnesses.Sealed: joinGap :: (Gap w) => (p -> q -> r) -> w p -> w q -> w r
+ Darcs.Witnesses.Sealed: joinGap :: Gap w => (p -> q -> r) -> w p -> w q -> w r
- Darcs.Witnesses.Sealed: liftSM :: (Monad m) => (a -> b) -> m (Sealed a) -> m b
+ Darcs.Witnesses.Sealed: liftSM :: Monad m => (a -> b) -> m (Sealed a) -> m b
- Darcs.Witnesses.Sealed: unsealM :: (Monad m) => m (Sealed a) -> (a -> m b) -> m b
+ Darcs.Witnesses.Sealed: unsealM :: Monad m => m (Sealed a) -> (a -> m b) -> m b
- Darcs.Witnesses.Show: show1 :: (Show1 a) => a -> String
+ Darcs.Witnesses.Show: show1 :: Show1 a => a -> String
- Darcs.Witnesses.Show: show2 :: (Show2 a) => a -> String
+ Darcs.Witnesses.Show: show2 :: Show2 a => a -> String
- Darcs.Witnesses.Show: showDict1 :: (Show1 a) => ShowDict (a)
+ Darcs.Witnesses.Show: showDict1 :: Show1 a => ShowDict (a)
- Darcs.Witnesses.Show: showDict2 :: (Show2 a) => ShowDict (a)
+ Darcs.Witnesses.Show: showDict2 :: Show2 a => ShowDict (a)
- Darcs.Witnesses.Show: showsPrec1 :: (Show1 a) => Int -> a -> ShowS
+ Darcs.Witnesses.Show: showsPrec1 :: Show1 a => Int -> a -> ShowS
- Darcs.Witnesses.Show: showsPrec2 :: (Show2 a) => Int -> a -> ShowS
+ Darcs.Witnesses.Show: showsPrec2 :: Show2 a => Int -> a -> ShowS
- English: englishNum :: (Countable n) => Int -> n -> ShowS
+ English: englishNum :: Countable n => Int -> n -> ShowS
- English: plural :: (Countable a) => a -> ShowS
+ English: plural :: Countable a => a -> ShowS
- English: singular :: (Countable a) => a -> ShowS
+ English: singular :: Countable a => a -> ShowS
- Lcs: aLen :: (IArray a e) => a Int e -> Int
+ Lcs: aLen :: IArray a e => a Int e -> Int

Files

Distribution/ShellHarness.hs view
@@ -2,8 +2,10 @@ module Distribution.ShellHarness ( runTests ) where  import Prelude hiding( catch )-import System.Directory ( getCurrentDirectory, setPermissions,-                          Permissions(..), getDirectoryContents,+import System.Directory ( getCurrentDirectory,+                          getPermissions, setPermissions,+                          readable, writable, executable, searchable,+                          getDirectoryContents,                           findExecutable, createDirectoryIfMissing,                           renameFile, removeFile ) import System.Environment ( getEnv, getEnvironment )@@ -110,8 +112,9 @@                  system $ "hpc sum --union --output=" ++ tixdir </> "sum.tix" ++ " " ++ unwords tixfiles                  forM tixfiles $ \f -> removeFile f                  return ()-             mapM_ (\x->-                  setPermissions x (Permissions+             mapM_ (\x-> do+                  p <- getPermissions x+                  setPermissions x (p                                    {readable = True                                    ,writable = True                                    ,executable = False
darcs.cabal view
@@ -1,5 +1,5 @@ Name:           darcs-version:        2.5+version:        2.5.1 License:        GPL License-file:   COPYING Author:         David Roundy <droundy@darcs.net>, <darcs-users@darcs.net>@@ -124,6 +124,8 @@   else     buildable: True +    build-tools: ghc >= 6.10 && < 7.2+     hs-source-dirs:   src     include-dirs:     src     cpp-options:      -DGADT_WITNESSES=1@@ -137,17 +139,23 @@     -- if not mentioned     other-modules:    Darcs.Test.Patch.Check -    extensions:-      CPP-      PatternGuards-      UndecidableInstances-      ScopedTypeVariables-      -- PatternSignatures is needed for GHC 6.8-      PatternSignatures-      RankNTypes-      GADTs-      TypeOperators+    if true+      extensions:+        CPP+        ForeignFunctionInterface+        PatternGuards+        UndecidableInstances+        ScopedTypeVariables+        -- PatternSignatures is needed for GHC 6.8+        PatternSignatures+        RankNTypes+        GADTs+        TypeOperators +    if impl(ghc>=7.0)+      extensions:+        NoMonoLocalBinds+     if os(windows)       hs-source-dirs: src/win32       include-dirs:   src/win32@@ -163,19 +171,19 @@     build-depends:   base          < 5,                      extensible-exceptions >= 0.1 && < 0.2,                      regex-compat >= 0.71 && < 0.94,-                     mtl          >= 1.0 && < 1.2,+                     mtl          >= 1.0 && < 2.1,                      parsec       >= 2.0 && < 3.1,                      html         == 1.0.*,-                     filepath     == 1.1.*,+                     filepath     >= 1.1.0.0 && < 1.3.0.0,                      haskeline    >= 0.6.2.2 && < 0.7,                      hashed-storage >= 0.5.2 && < 0.6,                      base >= 3,                      bytestring >= 0.9.0 && < 0.10,-                     text >= 0.3,+                     text == 0.11.*,                      old-time   == 1.0.*,-                     directory  == 1.0.*,+                     directory  >= 1.0.0.0 && < 1.2.0.0,                      process    == 1.0.*,-                     containers >= 0.1 && < 0.4,+                     containers >= 0.1 && < 0.5,                      array      >= 0.1 && < 0.4,                      random     == 1.0.*,                      tar          == 0.3.*,@@ -186,8 +194,8 @@     if !os(windows)       build-depends: unix >= 1.0 && < 2.5     if flag(http)-        build-depends:    network == 2.2.*,-                          HTTP    >= 3000.0 && < 4000.1+        build-depends:    network >= 2.2 && < 2.4,+                          HTTP    >= 3000.0 && < 4000.2   -- ----------------------------------------------------------------------@@ -200,6 +208,8 @@   else     buildable: True +    build-tools: ghc >= 6.10 && < 7.2+     hs-source-dirs:   src     include-dirs:     src @@ -356,6 +366,7 @@                       System.Posix.Files                       System.Posix.IO       cpp-options:    -DWIN32+      c-sources:      src/win32/send_email.c       build-depends:  unix-compat >= 0.1.2,                       regex-posix >= 0.94.4 && < 0.95 @@ -365,10 +376,10 @@     build-depends:   base          < 5,                      extensible-exceptions >= 0.1 && < 0.2,                      regex-compat >= 0.71 && < 0.94,-                     mtl          >= 1.0 && < 1.2,+                     mtl          >= 1.0 && < 2.1,                      parsec       >= 2.0 && < 3.1,                      html         == 1.0.*,-                     filepath     == 1.1.*,+                     filepath     >= 1.1.0.0 && < 1.3.0.0,                      haskeline    >= 0.6.2.2 && < 0.7,                      hashed-storage >= 0.5.2 && < 0.6,                      tar          == 0.3.*@@ -378,11 +389,11 @@      build-depends: base >= 3,                    bytestring >= 0.9.0 && < 0.10,-                   text >= 0.3,+                   text == 0.11.*,                    old-time   == 1.0.*,-                   directory  == 1.0.*,+                   directory  >= 1.0.0.0 && < 1.2.0.0,                    process    == 1.0.*,-                   containers >= 0.1 && < 0.4,+                   containers >= 0.1 && < 0.5,                    array      >= 0.1 && < 0.4,                    random     == 1.0.* @@ -408,8 +419,8 @@       cc-options:        -DHAVE_CURL      if flag(http)-        build-depends:    network == 2.2.*,-                          HTTP    >= 3000.0 && < 4000.1+        build-depends:    network >= 2.2 && < 2.4,+                          HTTP    >= 3000.0 && < 4000.2         cpp-options:      -DHAVE_HTTP         x-have-http: @@ -430,29 +441,34 @@     if flag(color)       x-use-color: -    extensions:-      CPP,-      ForeignFunctionInterface,-      BangPatterns,-      PatternGuards,-      MagicHash,-      UndecidableInstances,-      DeriveDataTypeable,-      GADTs,-      TypeOperators,-      ExistentialQuantification,-      FlexibleContexts,-      FlexibleInstances,-      ScopedTypeVariables,-      -- PatternSignatures is needed for GHC 6.8-      PatternSignatures,-      KindSignatures,-      TypeSynonymInstances,-      Rank2Types,-      RankNTypes,-      GeneralizedNewtypeDeriving,-      MultiParamTypeClasses+    if true+      extensions:+        CPP,+        ForeignFunctionInterface,+        BangPatterns,+        PatternGuards,+        MagicHash,+        UndecidableInstances,+        DeriveDataTypeable,+        GADTs,+        TypeOperators,+        ExistentialQuantification,+        FlexibleContexts,+        FlexibleInstances,+        ScopedTypeVariables,+        -- PatternSignatures is needed for GHC 6.8+        PatternSignatures,+        KindSignatures,+        TypeSynonymInstances,+        Rank2Types,+        RankNTypes,+        GeneralizedNewtypeDeriving,+        MultiParamTypeClasses +    if impl(ghc>=7.0)+      extensions:+        NoMonoLocalBinds+ -- ---------------------------------------------------------------------- -- darcs itself -- ----------------------------------------------------------------------@@ -467,6 +483,8 @@                     src/umask.c                     src/Crypt/sha2.c +  build-tools: ghc >= 6.10 && < 7.2+   -- We need optimizations, regardless of what Hackage says   -- Note: "if true" works around a cabal bug with order of flag composition   if true@@ -506,10 +524,10 @@   build-depends:   base          < 5,                    extensible-exceptions >= 0.1 && < 0.2,                    regex-compat >= 0.71 && < 0.94,-                   mtl          >= 1.0 && < 1.2,+                   mtl          >= 1.0 && < 2.1,                    parsec       >= 2.0 && < 3.1,                    html         == 1.0.*,-                   filepath     == 1.1.*,+                   filepath     >= 1.1.0.0 && < 1.3.0.0,                    haskeline    >= 0.6.2.2 && < 0.7,                    hashed-storage >= 0.5.2 && < 0.6,                    tar          == 0.3.*@@ -519,11 +537,11 @@    build-depends: base >= 3,                  bytestring >= 0.9.0 && < 0.10,-                 text >= 0.3,+                 text == 0.11.*,                    old-time   == 1.0.*,-                   directory  == 1.0.*,+                   directory  >= 1.0.0.0 && < 1.2.0.0,                    process    == 1.0.*,-                   containers >= 0.1 && < 0.4,+                   containers >= 0.1 && < 0.5,                    array      >= 0.1 && < 0.4,                    random     == 1.0.* @@ -535,8 +553,8 @@     cc-options:        -DHAVE_CURL    if flag(http)-      build-depends:    network == 2.2.*,-                        HTTP    >= 3000.0 && < 4000.1+      build-depends:    network >= 2.2 && < 2.4,+                        HTTP    >= 3000.0 && < 4000.2       cpp-options:      -DHAVE_HTTP       x-have-http: @@ -557,29 +575,34 @@   if flag(color)     x-use-color: -  extensions:-    CPP,-    ForeignFunctionInterface,-    BangPatterns,-    PatternGuards,-    MagicHash,-    UndecidableInstances,-    DeriveDataTypeable,-    GADTs,-    TypeOperators,-    ExistentialQuantification,-    FlexibleContexts,-    FlexibleInstances,-    ScopedTypeVariables,-    -- PatternSignatures is needed for GHC 6.8-    PatternSignatures,-    KindSignatures,-    TypeSynonymInstances,-    Rank2Types,-    RankNTypes,-    GeneralizedNewtypeDeriving,-    MultiParamTypeClasses+  if true+    extensions:+      CPP,+      ForeignFunctionInterface,+      BangPatterns,+      PatternGuards,+      MagicHash,+      UndecidableInstances,+      DeriveDataTypeable,+      GADTs,+      TypeOperators,+      ExistentialQuantification,+      FlexibleContexts,+      FlexibleInstances,+      ScopedTypeVariables,+      -- PatternSignatures is needed for GHC 6.8+      PatternSignatures,+      KindSignatures,+      TypeSynonymInstances,+      Rank2Types,+      RankNTypes,+      GeneralizedNewtypeDeriving,+      MultiParamTypeClasses +  if impl(ghc>=7.0)+    extensions:+      NoMonoLocalBinds+ -- ---------------------------------------------------------------------- -- unit test driver -- ----------------------------------------------------------------------@@ -591,13 +614,16 @@     buildable: False   else     buildable: True++    build-tools: ghc >= 6.10 && < 7.2+     build-depends:   base          < 5,                      extensible-exceptions >= 0.1 && < 0.2,                      regex-compat >= 0.71 && < 0.94,-                     mtl          >= 1.0 && < 1.2,+                     mtl          >= 1.0 && < 2.1,                      parsec       >= 2.0 && < 3.1,                      html         == 1.0.*,-                     filepath     == 1.1.*,+                     filepath     >= 1.1.0.0 && < 1.3.0.0,                      QuickCheck   >= 2.1.0.0,                      HUnit        >= 1.0,                      test-framework             >= 0.2.2,@@ -657,11 +683,11 @@     build-depends: base >= 3,                    bytestring >= 0.9.0 && < 0.10,                    haskeline    >= 0.6.2.2 && < 0.7,-                   text >= 0.3,+                   text == 0.11.*,                    old-time   == 1.0.*,-                   directory  == 1.0.*,+                   directory  >= 1.0.0.0 && < 1.2.0.0,                    process    == 1.0.*,-                   containers >= 0.1 && < 0.4,+                   containers >= 0.1 && < 0.5,                    array      >= 0.1 && < 0.4,                    hashed-storage >= 0.5.2 && < 0.6,                    random     == 1.0.*@@ -678,32 +704,37 @@       cpp-options:      -DHAVE_TERMINFO      if flag(http)-        build-depends:    network == 2.2.*,-                          HTTP    >= 3000.0 && < 4000.1+        build-depends:    network >= 2.2 && < 2.4,+                          HTTP    >= 3000.0 && < 4000.2      if flag(color)       x-use-color: -    extensions:-      CPP,-      ForeignFunctionInterface,-      BangPatterns,-      PatternGuards,-      MagicHash,-      UndecidableInstances,-      DeriveDataTypeable,-      GADTs,-      TypeOperators,-      ExistentialQuantification,-      FlexibleContexts,-      FlexibleInstances,-      ScopedTypeVariables,-      -- PatternSignatures is needed for GHC 6.8-      PatternSignatures,-      KindSignatures,-      TypeSynonymInstances,-      Rank2Types,-      RankNTypes,-      GeneralizedNewtypeDeriving,-      MultiParamTypeClasses-      OverlappingInstances+    if true+      extensions:+        CPP,+        ForeignFunctionInterface,+        BangPatterns,+        PatternGuards,+        MagicHash,+        UndecidableInstances,+        DeriveDataTypeable,+        GADTs,+        TypeOperators,+        ExistentialQuantification,+        FlexibleContexts,+        FlexibleInstances,+        ScopedTypeVariables,+        -- PatternSignatures is needed for GHC 6.8+        PatternSignatures,+        KindSignatures,+        TypeSynonymInstances,+        Rank2Types,+        RankNTypes,+        GeneralizedNewtypeDeriving,+        MultiParamTypeClasses+        OverlappingInstances++    if impl(ghc>=7.0)+      extensions:+        NoMonoLocalBinds
release/distributed-context view
@@ -1,1 +1,1 @@-Just "\nContext:\n\n[TAG 2.5\nReinier Lamers <tux_rocker@reinier.de>**20101024151805\n Ignore-this: 1561ce30bfb1950a440c03371e0e2f20\n] \n"+Just "\nContext:\n\n[TAG 2.5.1\nGanesh Sittampalam <ganesh@earth.li>**20110210233529\n Ignore-this: 9e4daeb4ceaf1c2743235c68564c519b\n] \n"
src/Darcs/Arguments.lhs view
@@ -271,8 +271,8 @@ getContent NonVerify = NoContent getContent NonForce = NoContent getContent DryRun = NoContent-getContent SetDefault = NoContent-getContent NoSetDefault = NoContent+getContent (SetDefault _) = NoContent+getContent (NoSetDefault _) = NoContent getContent FancyMoveAdd = NoContent getContent NoFancyMoveAdd = NoContent getContent Disable = NoContent@@ -347,6 +347,7 @@                           _ -> False  isin :: DarcsAtomicOption -> [DarcsFlag] -> Bool+(DarcsInternalOption f)             `isin` fs = f `elem` fs (DarcsNoArgOption _ _ f _)          `isin` fs = f `elem` fs (DarcsArgOption _ _ f _ _)          `isin` fs = any (`isa` f) fs (DarcsAbsPathOption _ _ f _ _)      `isin` fs = any (`isAnAbsolute` f) fs@@ -390,6 +391,11 @@     -- ^ @DarcsNoArgOption shortSwitches longSwitches mkFlag optDescr@     -- The constructon fon options with no arguments. +    | DarcsInternalOption DarcsFlag+    -- ^ @DarcsInternalOption@+    -- An option just for internal use (e.g. defaulting), not directly available to the user.++ data DarcsOption     = DarcsSingleOption DarcsAtomicOption     | DarcsMultipleChoiceOption [DarcsAtomicOption]@@ -423,6 +429,7 @@                      | otherwise = x : clear xs         clear [] = []         flags (DarcsNoArgOption _ _ fl _:xs) = fl : flags xs+        flags (DarcsInternalOption fl:xs) = fl : flags xs         flags (_:xs) = flags xs         flags [] = [] nubOptions (_:options) opts = nubOptions options opts@@ -433,15 +440,16 @@   getSetter (DarcsMutuallyExclusive _ f) = Just f   getSetter _ = Nothing -optionFromDarcsAtomicOption :: AbsolutePath -> DarcsAtomicOption -> OptDescr DarcsFlag-optionFromDarcsAtomicOption _ (DarcsNoArgOption a b c h) = Option a b (NoArg c) h-optionFromDarcsAtomicOption _ (DarcsArgOption a b c n h) = Option a b (ReqArg c n) h+optionFromDarcsAtomicOption :: AbsolutePath -> DarcsAtomicOption -> Maybe (OptDescr DarcsFlag)+optionFromDarcsAtomicOption wd (DarcsInternalOption _) = Nothing+optionFromDarcsAtomicOption _ (DarcsNoArgOption a b c h) = Just $ Option a b (NoArg c) h+optionFromDarcsAtomicOption _ (DarcsArgOption a b c n h) = Just $ Option a b (ReqArg c n) h optionFromDarcsAtomicOption wd (DarcsAbsPathOrStdOption a b c n h) =-  Option a b (ReqArg (c . makeAbsoluteOrStd wd) n) h+  Just $ Option a b (ReqArg (c . makeAbsoluteOrStd wd) n) h optionFromDarcsAtomicOption wd (DarcsAbsPathOption a b c n h) =-  Option a b (ReqArg (c . makeAbsolute wd) n) h+  Just $ Option a b (ReqArg (c . makeAbsolute wd) n) h optionFromDarcsAtomicOption wd (DarcsOptAbsPathOption a b d c n h) =-  Option a b (OptArg (c . makeAbsolute wd . fromMaybe d) n) h+  Just $ Option a b (OptArg (c . makeAbsolute wd . fromMaybe d) n) h  atomicOptions :: DarcsOption -> [DarcsAtomicOption] atomicOptions (DarcsSingleOption x) = [x]@@ -449,7 +457,7 @@ atomicOptions (DarcsMutuallyExclusive xs _) = xs  optionFromDarcsOption :: AbsolutePath -> DarcsOption -> [OptDescr DarcsFlag]-optionFromDarcsOption wd = map (optionFromDarcsAtomicOption wd) . atomicOptions+optionFromDarcsOption wd = mapMaybe (optionFromDarcsAtomicOption wd) . atomicOptions  -- | 'concat_option' creates a DarcsMultipleChoiceOption from a list of -- option, flattening any DarcsMultipleChoiceOption in the list.@@ -1098,13 +1106,17 @@  setDefault :: Bool -> DarcsOption setDefault wantYes-  | wantYes   = mkMutuallyExclusive [] yes [no]-  | otherwise = mkMutuallyExclusive [yes] no []+  | wantYes   = mkMutuallyExclusive [yes,no] defaultyes []+  | otherwise = mkMutuallyExclusive [yes,no] defaultno  []  where-  yes = ( DarcsNoArgOption [] ["set-default"], SetDefault-        , "set default repository" )-  no  = ( DarcsNoArgOption [] ["no-set-default"], NoSetDefault-        , "don't set default repository" )+  yes = ( DarcsNoArgOption [] ["set-default"], SetDefault True+        , "set default repository" ++ defaultText wantYes )+  no  = ( DarcsNoArgOption [] ["no-set-default"], NoSetDefault True+        , "don't set default repository" ++ defaultText (not wantYes) )+  defaultyes = ( \f _ -> DarcsInternalOption f, SetDefault False, "" )+  defaultno = ( \f _ -> DarcsInternalOption f, NoSetDefault False, "" )+  defaultText True = " [DEFAULT]"+  defaultText False = ""  verify = DarcsMultipleChoiceOption          [DarcsAbsPathOption [] ["verify"] Verify "PUBRING"@@ -1397,6 +1409,7 @@ optionListLatex (DarcsMutuallyExclusive os _) = unlines (map optionLatex os)  optionLatex :: DarcsAtomicOption -> String+optionLatex (DarcsInternalOption _) = "" optionLatex (DarcsNoArgOption a b _ h) =     showShortOptions a ++ showLongOptions b ++ latexHelp h ++ "\\\\" optionLatex (DarcsArgOption a b _ arg h) =
src/Darcs/Commands.lhs view
@@ -17,7 +17,7 @@  \begin{code} module Darcs.Commands ( CommandControl( CommandData, HiddenCommand, GroupName ),-                       DarcsCommand( DarcsCommand, commandName,+                       DarcsCommand( DarcsCommand, commandProgramName, commandName,                                      commandHelp, commandDescription,                                      commandBasicOptions, commandAdvancedOptions,                                      commandCommand,@@ -128,7 +128,7 @@                     | GroupName String  data DarcsCommand =-    DarcsCommand {commandName, commandHelp, commandDescription :: String,+    DarcsCommand {commandProgramName, commandName, commandHelp, commandDescription :: String,                   commandExtraArgs :: Int,                   commandExtraArgHelp :: [String],                   commandCommand :: [DarcsFlag] -> [String] -> IO (),@@ -137,7 +137,7 @@                   commandArgdefaults :: [DarcsFlag] -> AbsolutePath -> [String] -> IO [String],                   commandBasicOptions :: [DarcsOption],                   commandAdvancedOptions :: [DarcsOption]}-  | SuperCommand {commandName, commandHelp, commandDescription :: String,+  | SuperCommand {commandProgramName, commandName, commandHelp, commandDescription :: String,                   commandPrereq :: [DarcsFlag] -> IO (Either String ()),                   commandSubCommands :: [CommandControl]} @@ -171,9 +171,9 @@ commandAlias :: String -> Maybe DarcsCommand -> DarcsCommand -> DarcsCommand commandAlias n msuper c =   c { commandName = n-    , commandDescription = "Alias for `darcs " ++ cmdName ++ "'."-    , commandHelp = "The `darcs " ++ n ++ "' command is an alias for " ++-                     "`darcs " ++ cmdName ++ "'.\n" +++    , commandDescription = "Alias for `" ++ commandProgramName c ++ " " ++ cmdName ++ "'."+    , commandHelp = "The `" ++ commandProgramName c ++ " " ++ n ++ "' command is an alias for " +++                     "`" ++ commandProgramName c ++ " " ++ cmdName ++ "'.\n" ++                      commandHelp c     }  where@@ -201,7 +201,7 @@ subusage :: DarcsCommand -> String subusage super =     (usageInfo-     ("Usage: darcs "++commandName super++" SUBCOMMAND ... " +++     ("Usage: " ++ commandProgramName super ++ " "++commandName super++" SUBCOMMAND ... " ++       "\n\n"++ commandDescription super++       "\n\nSubcommands:\n" ++ usageHelper (getSubcommands super) ++ "\nOptions:")      (optionFromDarcsOption rootDirectory help))@@ -228,7 +228,7 @@ getCommandMiniHelp :: Maybe DarcsCommand -> DarcsCommand -> String getCommandMiniHelp msuper cmd =   getCommandHelpCore msuper cmd ++-  "\n\nSee darcs help "+  "\n\nSee " ++ commandProgramName cmd ++ " help "   ++ (maybe "" (\c -> commandName c ++ " ") msuper)   ++ commandName cmd ++ " for details." @@ -256,11 +256,11 @@  getCommandHelpCore :: Maybe DarcsCommand -> DarcsCommand -> String getCommandHelpCore msuper cmd =-    "Usage: darcs "++superName msuper++commandName cmd+++    "Usage: " ++ commandProgramName cmd ++ " "++superName msuper++commandName cmd++     " [OPTION]... " ++ unwords args_help ++     "\n"++ commandDescription cmd     where args_help = case cmd of-            (DarcsCommand _ _ _ _ _ _ _ _ _ _ _) ->+            (DarcsCommand {}) ->               commandExtraArgHelp cmd             _ -> [] 
src/Darcs/Commands/Add.lhs view
@@ -69,7 +69,8 @@  "Adding symbolic links (symlinks) is not supported.\n\n"  add :: DarcsCommand-add = DarcsCommand {commandName = "add",+add = DarcsCommand {commandProgramName = "darcs",+                    commandName = "add",                     commandHelp = addHelp ++ addHelp' ++ addHelp'',                     commandDescription = addDescription,                     commandExtraArgs = -1,
src/Darcs/Commands/AmendRecord.lhs view
@@ -103,7 +103,8 @@  "On Windows use C:/Documents And Settings/user/Application Data/darcs/defaults\n"  amendrecord :: DarcsCommand-amendrecord = DarcsCommand {commandName = "amend-record",+amendrecord = DarcsCommand {commandProgramName = "darcs",+                            commandName = "amend-record",                             commandHelp = amendrecordHelp,                             commandDescription = amendrecordDescription,                             commandExtraArgs = -1,
src/Darcs/Commands/Annotate.lhs view
@@ -83,7 +83,8 @@  "option can be used to generate output for machine postprocessing.\n"  annotate :: DarcsCommand-annotate = DarcsCommand {commandName = "annotate",+annotate = DarcsCommand {commandProgramName = "darcs",+                         commandName = "annotate",                          commandHelp = annotateHelp,                          commandDescription = annotateDescription,                          commandExtraArgs = -1,
src/Darcs/Commands/Apply.lhs view
@@ -122,7 +122,8 @@ stdindefault _ [] = return ["-"] stdindefault _ x = return x apply :: DarcsCommand-apply = DarcsCommand {commandName = "apply",+apply = DarcsCommand {commandProgramName = "darcs",+                      commandName = "apply",                       commandHelp = applyHelp ++ "\n" ++ applyHelp',                       commandDescription = applyDescription,                       commandExtraArgs = 1,
src/Darcs/Commands/Changes.lhs view
@@ -85,7 +85,8 @@  "\n" ++ changesHelp''  changes :: DarcsCommand-changes = DarcsCommand {commandName = "changes",+changes = DarcsCommand {commandProgramName = "darcs",+                        commandName = "changes",                         commandHelp = changesHelp,                         commandDescription = changesDescription,                         commandExtraArgs = -1,
src/Darcs/Commands/Check.lhs view
@@ -62,7 +62,8 @@  "by `darcs check'.  Use the --no-test option to disable this.\n"  check :: DarcsCommand-check = DarcsCommand {commandName = "check",+check = DarcsCommand {commandProgramName = "darcs",+                      commandName = "check",                       commandHelp = checkHelp,                       commandDescription = checkDescription,                       commandExtraArgs = 0,
src/Darcs/Commands/Convert.lhs view
@@ -116,7 +116,8 @@  "than once.)\n"  convert :: DarcsCommand-convert = DarcsCommand {commandName = "convert",+convert = DarcsCommand {commandProgramName = "darcs",+                    commandName = "convert",                     commandHelp = convertHelp,                     commandDescription = convertDescription,                     commandExtraArgs = -1,
src/Darcs/Commands/Diff.lhs view
@@ -75,7 +75,8 @@  "formatted as the output of a diff command\n"  diffCommand :: DarcsCommand-diffCommand = DarcsCommand {commandName = "diff",+diffCommand = DarcsCommand {commandProgramName = "darcs",+                             commandName = "diff",                              commandHelp = diffHelp,                              commandDescription = diffDescription,                              commandExtraArgs = -1,
src/Darcs/Commands/Dist.lhs view
@@ -31,12 +31,7 @@ import Prelude hiding ( writeFile ) import Data.ByteString.Lazy ( writeFile ) -import Darcs.Commands ( DarcsCommand(DarcsCommand, commandName, commandHelp,-                        commandDescription, commandExtraArgs,-                        commandExtraArgHelp, commandCommand,-                        commandPrereq, commandGetArgPossibilities,-                        commandArgdefaults,-                        commandAdvancedOptions, commandBasicOptions),+import Darcs.Commands ( DarcsCommand(..),                         nodefaults ) import Darcs.Arguments ( DarcsFlag(Verbose, DistName), distnameOption,                          workingRepoDir, matchOne, storeInMemory,@@ -85,7 +80,8 @@  -}  dist :: DarcsCommand-dist = DarcsCommand {commandName = "dist",+dist = DarcsCommand {commandProgramName = "darcs",+                     commandName = "dist",                      commandHelp = distHelp,                      commandDescription = distDescription,                      commandExtraArgs = 0,
src/Darcs/Commands/GZCRCs.lhs view
@@ -119,7 +119,8 @@       when verbose $ hPutStrLn stderr $ unlines ("The following corrupt files were found:":files)  gzcrcs :: DarcsCommand-gzcrcs = DarcsCommand {commandName = "gzcrcs",+gzcrcs = DarcsCommand {commandProgramName = "darcs",+                       commandName = "gzcrcs",                        commandHelp = gzcrcsHelp,                        commandDescription = gzcrcsDescription,                        commandExtraArgs = 0,
src/Darcs/Commands/Get.lhs view
@@ -117,7 +117,8 @@  "is required.\n"  get :: DarcsCommand-get = DarcsCommand {commandName = "get",+get = DarcsCommand {commandProgramName = "darcs",+                    commandName = "get",                     commandHelp = getHelp,                     commandDescription = getDescription,                     commandExtraArgs = -1,@@ -200,11 +201,15 @@                                    debugMessage "Identifying and copying repository..."                                    copyRepoHashed repository                                | hashUs -> do-                                   putInfo opts $  text "Converting old-fashioned repository to hashed format..."-                                               $$ text "*******************************************************************************"-                                               $$ text "Fetching a hashed repository would be faster.  Perhaps you could persuade"-                                               $$ text "the maintainer to run darcs optimize --upgrade with darcs 2.4.0 or higher?"-                                               $$ text "*******************************************************************************"+                                   putInfo opts $ text "***********************************************************************"+                                               $$ text "  _______   Sorry for the wait! The repository you are fetching is"+                                               $$ text " |       |  using the DEPRECATED 'old-fashioned' format. I'm getting a"+                                               $$ text " | O   O |  hashed copy instead, but this may take a while."+                                               $$ text " |  ___  |"+                                               $$ text " | /   \\ |  We recommend that the maintainer upgrade the remote copy"+                                               $$ text " |_______|  as well. See http://wiki.darcs.net/OF for more information."+                                               $$ text ""+                                               $$ text "***********************************************************************"                                    copyRepoHashed repository                                | hashThem -> do                                    putInfo opts $ text "Fetching a hashed repository as an old-fashioned one..."
src/Darcs/Commands/Help.lhs view
@@ -53,7 +53,8 @@  "`darcs help foo' prints detailed help about the darcs command foo.\n"  help :: DarcsCommand-help = DarcsCommand {commandName = "help",+help = DarcsCommand {commandProgramName = "darcs",+                     commandName = "help",                      commandHelp = helpHelp,                      commandDescription = helpDescription,                      commandExtraArgs = -1,
src/Darcs/Commands/Init.lhs view
@@ -70,7 +70,8 @@  "Initialize is commonly abbreviated to `init'.\n"  initialize :: DarcsCommand-initialize = DarcsCommand {commandName = "initialize",+initialize = DarcsCommand {commandProgramName = "darcs",+                         commandName = "initialize",                          commandHelp = initializeHelp,                          commandDescription = initializeDescription,                          commandExtraArgs = 0,
src/Darcs/Commands/MarkConflicts.lhs view
@@ -64,7 +64,8 @@  "alias still exists for backwards-compatibility.\n"  markconflicts :: DarcsCommand-markconflicts = DarcsCommand {commandName = "mark-conflicts",+markconflicts = DarcsCommand {commandProgramName = "darcs",+                              commandName = "mark-conflicts",                               commandHelp = markconflictsHelp,                               commandDescription = markconflictsDescription,                               commandExtraArgs = 0,
src/Darcs/Commands/Move.lhs view
@@ -74,7 +74,8 @@  "unusable on those systems!\n"  move :: DarcsCommand-move = DarcsCommand {commandName = "move",+move = DarcsCommand {commandProgramName = "darcs",+                   commandName = "move",                    commandHelp = moveHelp,                    commandDescription = moveDescription,                    commandExtraArgs = -1,
src/Darcs/Commands/Optimize.lhs view
@@ -122,7 +122,8 @@  "unversioned files in _darcs/prefs/ (such as _darcs/prefs/author).\n"  optimize :: DarcsCommand-optimize = DarcsCommand {commandName = "optimize",+optimize = DarcsCommand {commandProgramName = "darcs",+                         commandName = "optimize",                          commandHelp = optimizeHelp,                          commandDescription = optimizeDescription,                          commandExtraArgs = 0,
src/Darcs/Commands/Pull.lhs view
@@ -111,7 +111,8 @@  fetch :: DarcsCommand fetch = DarcsCommand {-         commandName = "fetch",+         commandProgramName = "darcs",+	 commandName = "fetch",          commandHelp = fetchHelp,          commandDescription = fetchDescription,          commandExtraArgs = -1,@@ -134,7 +135,8 @@                                   allowUnrelatedRepos]}  pull :: DarcsCommand-pull = DarcsCommand {commandName = "pull",+pull = DarcsCommand {commandProgramName = "darcs",+                     commandName = "pull",                      commandHelp = pullHelp,                      commandDescription = pullDescription,                      commandExtraArgs = -1,
src/Darcs/Commands/Push.lhs view
@@ -75,7 +75,8 @@  "current repository into another repository.\n"  push :: DarcsCommand-push = DarcsCommand {commandName = "push",+push = DarcsCommand {commandProgramName = "darcs",+                     commandName = "push",                      commandHelp = pushHelp,                      commandDescription = pushDescription,                      commandExtraArgs = 1,
src/Darcs/Commands/Put.lhs view
@@ -55,7 +55,8 @@  "appropriate.  See those commands for an explanation of each option.\n"  put ::DarcsCommand-put = DarcsCommand {commandName = "put",+put = DarcsCommand {commandProgramName = "darcs",+                    commandName = "put",                     commandHelp = putHelp,                     commandDescription = putDescription,                     commandExtraArgs = 1,
src/Darcs/Commands/Record.lhs view
@@ -91,7 +91,8 @@  "\n" ++ recordHelp''  record :: DarcsCommand-record = DarcsCommand {commandName = "record",+record = DarcsCommand {commandProgramName = "darcs",+                       commandName = "record",                        commandHelp = recordHelp,                        commandDescription = recordDescription,                        commandExtraArgs = -1,
src/Darcs/Commands/Remove.lhs view
@@ -65,7 +65,8 @@  "the patch) will ALWAYS affect the working tree of that repository.\n"  remove :: DarcsCommand-remove = DarcsCommand {commandName = "remove",+remove = DarcsCommand {commandProgramName = "darcs",+                       commandName = "remove",                        commandHelp = removeHelp,                        commandDescription = removeDescription,                        commandExtraArgs = -1,
src/Darcs/Commands/Repair.lhs view
@@ -40,7 +40,8 @@  "which is where most corruption occurs.\n"  repair :: DarcsCommand-repair = DarcsCommand {commandName = "repair",+repair = DarcsCommand {commandProgramName = "darcs",+                       commandName = "repair",                        commandHelp = repairHelp,                        commandDescription = repairDescription,                        commandExtraArgs = 0,
src/Darcs/Commands/Replace.lhs view
@@ -26,11 +26,7 @@ import Control.Monad ( unless, filterM ) import Control.Applicative( (<$>) ) -import Darcs.Commands ( DarcsCommand(DarcsCommand, commandName, commandHelp,-                        commandDescription, commandExtraArgs,-                        commandExtraArgHelp, commandCommand, commandPrereq,-                        commandGetArgPossibilities, commandArgdefaults,-                        commandAdvancedOptions, commandBasicOptions),+import Darcs.Commands ( DarcsCommand(..),                         nodefaults ) import Darcs.Arguments ( DarcsFlag(ForceReplace, Toks), listRegisteredFiles,                          ignoretimes, umaskOption, tokens, forceReplace,@@ -146,7 +142,8 @@ \begin{code}  replace :: DarcsCommand-replace = DarcsCommand {commandName = "replace",+replace = DarcsCommand {commandProgramName = "darcs",+                        commandName = "replace",                         commandHelp = replaceHelp,                         commandDescription = replaceDescription,                         commandExtraArgs = -1,
src/Darcs/Commands/Revert.lhs view
@@ -65,7 +65,8 @@  "revert' ran.\n"  revert :: DarcsCommand-revert = DarcsCommand {commandName = "revert",+revert = DarcsCommand {commandProgramName = "darcs",+                       commandName = "revert",                        commandHelp = revertHelp,                        commandDescription = revertDescription,                        commandExtraArgs = -1,
src/Darcs/Commands/Rollback.lhs view
@@ -79,7 +79,8 @@  "of its changes.\n"  rollback :: DarcsCommand-rollback = DarcsCommand {commandName = "rollback",+rollback = DarcsCommand {commandProgramName = "darcs",+                         commandName = "rollback",                          commandHelp = rollbackHelp,                          commandDescription = rollbackDescription,                          commandExtraArgs = -1,
src/Darcs/Commands/Send.lhs view
@@ -115,7 +115,8 @@  \begin{code} send :: DarcsCommand-send = DarcsCommand {commandName = "send",+send = DarcsCommand {commandProgramName = "darcs",+                     commandName = "send",                      commandHelp = sendHelp,                      commandDescription = sendDescription,                      commandExtraArgs = 1,@@ -152,12 +153,12 @@         here <- getCurrentDirectory         when (repodir == toFilePath here) $            fail ("Can't send to current repository! Did you mean send --context?")-        repo <- identifyRepositoryFor repository repodir-        them <- readRepo repo         old_default <- getPreflist "defaultrepo"-        setDefaultrepo repodir input_opts         when (old_default == [repodir] && not (Quiet `elem` input_opts)) $              putStrLn $ "Creating patch to "++formatPath repodir++"..."+        repo <- identifyRepositoryFor repository repodir+        them <- readRepo repo+        setDefaultrepo repodir input_opts         wtds <- decideOnBehavior input_opts repo         sendToThem repository input_opts wtds repodir them     where the_context [] = return Nothing
src/Darcs/Commands/SetPref.lhs view
@@ -73,7 +73,8 @@  "low-priority bug, because preferences are seldom set.\n"  setpref :: DarcsCommand-setpref = DarcsCommand {commandName = "setpref",+setpref = DarcsCommand {commandProgramName = "darcs",+                        commandName = "setpref",                         commandHelp = setprefHelp,                         commandDescription = setprefDescription,                         commandExtraArgs = 2,
src/Darcs/Commands/Show.lhs view
@@ -43,7 +43,8 @@  "Currently this is a deprecated alias.\n"  showCommand :: DarcsCommand-showCommand = SuperCommand {commandName = "show",+showCommand = SuperCommand {commandProgramName = "darcs",+                      commandName = "show",                       commandHelp = showHelp,                       commandDescription = showDescription,                       commandPrereq = amInRepository,
src/Darcs/Commands/ShowAuthors.lhs view
@@ -89,6 +89,7 @@  showAuthors :: DarcsCommand showAuthors = DarcsCommand {+  commandProgramName = "darcs",   commandName = "authors",   commandHelp = showAuthorsHelp,   commandDescription = showAuthorsDescription,
src/Darcs/Commands/ShowBug.lhs view
@@ -36,7 +36,8 @@   ++"a bug in darcs.\n"  showBug :: DarcsCommand-showBug = DarcsCommand {commandName = "bug",+showBug = DarcsCommand {commandProgramName = "darcs",+                         commandName = "bug",                          commandHelp = showBugHelp,                          commandDescription = showBugDescription,                          commandExtraArgs = 0,
src/Darcs/Commands/ShowContents.lhs view
@@ -48,7 +48,8 @@   "version of the file(s).\n"  showContents :: DarcsCommand-showContents = DarcsCommand {commandName = "contents",+showContents = DarcsCommand {commandProgramName = "darcs",+                              commandName = "contents",                               commandHelp = showContentsHelp,                               commandDescription = showContentsDescription,                               commandExtraArgs = -1,
src/Darcs/Commands/ShowFiles.lhs view
@@ -67,6 +67,7 @@  showFiles :: DarcsCommand showFiles = DarcsCommand {+  commandProgramName = "darcs",   commandName = "files",   commandHelp = showFilesHelp,   commandDescription = showFilesDescription,
src/Darcs/Commands/ShowIndex.lhs view
@@ -44,6 +44,7 @@  showIndex :: DarcsCommand showIndex = DarcsCommand {+  commandProgramName = "darcs",   commandName = "index",   commandDescription = "Dump contents of working tree index.",   commandHelp =
src/Darcs/Commands/ShowRepo.lhs view
@@ -56,7 +56,8 @@ showRepoDescription = "Show repository summary information"  showRepo :: DarcsCommand-showRepo = DarcsCommand { commandName = "repo",+showRepo = DarcsCommand { commandProgramName = "darcs",+                           commandName = "repo",                            commandHelp = showRepoHelp,                            commandDescription = showRepoDescription,                            commandExtraArgs = 0,
src/Darcs/Commands/ShowTags.lhs view
@@ -42,6 +42,7 @@  showTags :: DarcsCommand showTags = DarcsCommand {+  commandProgramName = "darcs",   commandName = "tags",   commandHelp = showTagsHelp,   commandDescription = showTagsDescription,
src/Darcs/Commands/Tag.lhs view
@@ -21,12 +21,7 @@ import System.Directory ( removeFile ) import Control.Monad ( when ) -import Darcs.Commands ( DarcsCommand(DarcsCommand, commandName, commandHelp,-                        commandDescription, commandExtraArgs,-                        commandExtraArgHelp, commandCommand, commandPrereq,-                        commandGetArgPossibilities, commandArgdefaults,-                        commandAdvancedOptions, commandBasicOptions),-                        nodefaults )+import Darcs.Commands ( DarcsCommand(..), nodefaults ) import Darcs.Arguments ( nocompress, umaskOption, patchnameOption, author,                          pipeInteractive, askLongComment,                          workingRepoDir, getAuthor )@@ -71,7 +66,8 @@  "described in `darcs record'.\n"  tag :: DarcsCommand-tag = DarcsCommand {commandName = "tag",+tag = DarcsCommand {commandProgramName = "darcs",+                    commandName = "tag",                     commandHelp = tagHelp,                     commandDescription = tagDescription,                     commandExtraArgs = -1,
src/Darcs/Commands/TrackDown.lhs view
@@ -60,7 +60,8 @@  "found at random."  trackdown :: DarcsCommand-trackdown = DarcsCommand {commandName = "trackdown",+trackdown = DarcsCommand {commandProgramName = "darcs",+                          commandName = "trackdown",                           commandHelp = trackdownHelp,                           commandDescription = trackdownDescription,                           commandExtraArgs = -1,
src/Darcs/Commands/TransferMode.lhs view
@@ -52,7 +52,8 @@  "hundreds of times!\n"  transferMode :: DarcsCommand-transferMode = DarcsCommand {commandName = "transfer-mode",+transferMode = DarcsCommand {commandProgramName = "darcs",+                              commandName = "transfer-mode",                               commandHelp = transferModeHelp,                               commandDescription = transferModeDescription,                               commandExtraArgs = 0,
src/Darcs/Commands/Unrecord.lhs view
@@ -147,7 +147,8 @@  "another user may have already pulled the patch.\n"  unrecord :: DarcsCommand-unrecord = DarcsCommand {commandName = "unrecord",+unrecord = DarcsCommand {commandProgramName = "darcs",+                         commandName = "unrecord",                          commandHelp = unrecordHelp,                          commandDescription = unrecordDescription,                          commandExtraArgs = 0,@@ -272,7 +273,8 @@  \begin{code} obliterate :: DarcsCommand-obliterate = DarcsCommand {commandName = "obliterate",+obliterate = DarcsCommand {commandProgramName = "darcs",+                           commandName = "obliterate",                            commandHelp = obliterateHelp,                            commandDescription = obliterateDescription,                            commandExtraArgs = 0,
src/Darcs/Commands/Unrevert.lhs view
@@ -71,7 +71,8 @@  "interactive command that will DEFINITELY prevent unreversion.\n"  unrevert :: DarcsCommand-unrevert = DarcsCommand {commandName = "unrevert",+unrevert = DarcsCommand {commandProgramName = "darcs",+                         commandName = "unrevert",                          commandHelp = unrevertHelp,                          commandDescription = unrevertDescription,                          commandExtraArgs = 0,
src/Darcs/Commands/WhatsNew.lhs view
@@ -91,7 +91,8 @@  "there are no unrecorded changes.\n"  whatsnew :: DarcsCommand-whatsnew = DarcsCommand {commandName = "whatsnew",+whatsnew = DarcsCommand {commandProgramName = "darcs",+                         commandName = "whatsnew",                          commandHelp = whatsnewHelp,                          commandDescription = whatsnewDescription,                          commandExtraArgs = -1,
src/Darcs/CommandsAux.hs view
@@ -21,6 +21,7 @@ #include "gadts.h"  module Darcs.CommandsAux ( checkPaths, maliciousPatches, hasMaliciousPath,+                           isMaliciousPath, isMaliciousSubPath,                         ) where import Darcs.Flags ( DarcsFlag( RestrictPaths, DontRestrictPaths ) ) import Darcs.Patch ( Patchy, listTouchedFiles )@@ -28,7 +29,7 @@ import Darcs.Witnesses.Sealed ( Sealed2(..), unseal2 ) import Darcs.Global ( darcsdir ) import Data.List ( intersect )-import System.FilePath ( splitDirectories )+import System.FilePath ( splitDirectories, isRelative )  -- * File paths {-@@ -102,7 +103,17 @@ -} isMaliciousPath :: String -> Bool isMaliciousPath fp =-    not (isExplicitlyRelative fp) ||+    not (isExplicitlyRelative fp) || isGenerallyMalicious fp++-- | Warning : this is less rigorous than isMaliciousPath+--   but it's to allow for subpath representations that+--   don't start with ./+isMaliciousSubPath :: String -> Bool+isMaliciousSubPath fp =+    not (isRelative fp) || isGenerallyMalicious fp++isGenerallyMalicious :: String -> Bool+isGenerallyMalicious fp =     splitDirectories fp `contains_any` [ "..", darcsdir ]  where     contains_any a b = not . null $ intersect a b
src/Darcs/Flags.hs view
@@ -83,7 +83,15 @@                | OnePattern PatchMatch | SeveralPattern PatchMatch                | AfterPattern PatchMatch | UpToPattern PatchMatch                | NonApply | NonVerify | NonForce-               | DryRun | SetDefault | NoSetDefault+               | DryRun++               -- The Bool parameters are a bit of a hack so that we can tell+               -- whether the user explicitly set the option or not.+               -- A more general mechanism would be better.+               -- True = explicitly set by user (on command-line or in prefs/defaults),+               -- False = defaulted by darcs+               | SetDefault Bool | NoSetDefault Bool+                | FancyMoveAdd | NoFancyMoveAdd                | Disable | SetScriptsExecutable | DontSetScriptsExecutable | Bisect                | UseHashedInventory | UseOldFashionedInventory
src/Darcs/Patch/Choices.hs view
@@ -62,7 +62,8 @@                       substitute                     ) where -import Control.Monad.State( State(..) )+import Control.Monad.Identity ( Identity )+import Control.Monad.State( StateT(..) )  import Darcs.Patch import Darcs.Patch.Permutations ( commuteWhatWeCanRL, commuteWhatWeCanFL )@@ -252,8 +253,8 @@     settleB bubble = mapFL_FL (\tp -> PC tp True) $ reverseRL bubble  patchSlot' :: Patchy p =>-              TaggedPatch p C(a b) -> State (PatchChoices p C(x y)) Slot-patchSlot' = State . patchSlot+              TaggedPatch p C(a b) -> StateT (PatchChoices p C(x y)) Identity Slot+patchSlot' tp = StateT (return . patchSlot tp)  forceMatchingFirst :: forall p C(a b). Patchy p =>                       ( FORALL(x y) TaggedPatch p C(x y) -> Bool)
src/Darcs/Patch/Commute.lhs view
@@ -765,8 +765,9 @@           nchs = sort $ map (makeChunk l) newfs           filename = getAFilename pss           old = makeChunk l oldf-          new = [top] ++ concat (intersperse [middle] nchs) ++ [bottom]+          new = [top] ++ old ++ [initial] ++ concat (intersperse [middle] nchs) ++ [bottom]           top    = BC.pack $ "v v v v v v v" ++ eol_c+          initial= BC.pack $ "=============" ++ eol_c           middle = BC.pack $ "*************" ++ eol_c           bottom = BC.pack $ "^ ^ ^ ^ ^ ^ ^" ++ eol_c           eol_c  = if any (\ps -> not (B.null ps) && BC.last ps == '\r') old
src/Darcs/Patch/Split.hs view
@@ -133,6 +133,7 @@                                  , "   - To split removed text, copy back the part you want to retain"                                  , ""                                  ]+          hunk :: [B.ByteString] -> [B.ByteString] -> FL Prim C(a b)           hunk b a = canonize (FP fn (Hunk n b a))           mkSep s = BC.append sep (BC.pack s)           breakSep xs = case break (sep `BC.isPrefixOf`) xs of
src/Darcs/Repository.hs view
@@ -54,7 +54,8 @@  import Darcs.Repository.Internal     (Repository(..), RepoType(..), ($-),-     maybeIdentifyRepository, identifyRepositoryFor, IdentifyRepo(..),+     maybeIdentifyRepository, identifyRepositoryFor, identifyDarcsRepository,+     IdentifyRepo(..),      findRepository, amInRepository, amNotInRepository,      makePatchLazy,      withRecorded,@@ -102,7 +103,8 @@                                , reverseRL ,lengthRL, (+>+), (:\/:)(..) ) import Darcs.Patch.Info ( PatchInfo ) import Darcs.Repository.Format ( RepoProperty ( HashedInventory ), RepoFormat,-                                 createRepoFormat, formatHas, writeRepoFormat )+                                 createRepoFormat, formatHas, writeRepoFormat,+                                 readfromAndWritetoProblem) import Darcs.Repository.Prefs ( writeDefaultPrefs ) import Darcs.Repository.Pristine ( createPristine, flagsToPristine, createPristineFromWorking ) import Darcs.Patch.Depends ( getPatchesBeyondTag, areUnrelatedRepos, findUncommon )@@ -170,7 +172,11 @@ copyInventory :: forall p C(r u t). RepoPatch p => Repository p C(r u t) -> IO () copyInventory fromRepo@(Repo fromDir opts fromFormat (DarcsRepository _ fromCache)) = do   toRepo@(Repo toDir opts' toFormat (DarcsRepository toPristine toCache)) <--    identifyRepositoryFor fromRepo "."+    identifyDarcsRepository opts "."+  let (_ :: Repository p C(r u t)) = toRepo --The witnesses are wrong, but cannot escape+  case readfromAndWritetoProblem fromFormat toFormat of+    Just e ->  fail $ "Incompatibility with repository " ++ fromDir ++ ":\n" ++ e+    Nothing -> return ()   toCache2 <- unionRemoteCaches toCache fromCache fromDir   let toRepo2 :: Repository p C(r u t)       toRepo2 = Repo toDir opts' toFormat $ DarcsRepository toPristine toCache2
src/Darcs/Repository/HashedIO.hs view
@@ -21,7 +21,9 @@  module Darcs.Repository.HashedIO ( HashedIO,                                    copyHashed, copyPartialsHashed,-                                   cleanHashdir ) where+                                   cleanHashdir,+                                   RW(RW) -- only exported to make warning go away+                                 ) where  import Darcs.Global ( darcsdir ) import qualified Data.Set as Set@@ -31,15 +33,13 @@ import Control.Applicative ( (<$>) ) import Data.Maybe ( isJust ) import System.IO.Unsafe ( unsafeInterleaveIO )-import System.IO ( hPutStrLn, stderr )  import Darcs.Repository.Cache ( Cache(..), fetchFileUsingCache, writeFileUsingCache,                                 peekInCache, speculateFileUsingCache,                                 okayHash, cleanCachesWithHint, HashedDir(..), hashedDir )-import Darcs.Patch ( Patchy, apply ) import Darcs.RepoPath ( FilePathLike, toFilePath ) import Darcs.IO ( ReadableDirectory(..), WriteableDirectory(..) )-import Darcs.Flags ( DarcsFlag, Compression( .. ) )+import Darcs.Flags ( Compression( .. ) ) import Darcs.Lock ( writeAtomicFilePS, removeFileMayNotExist ) import Darcs.Utils ( withCurrentDirectory ) import Progress ( debugMessage, tediousSize, finishedOneIO )@@ -50,11 +50,10 @@ import qualified Data.ByteString       as B  (ByteString, length, empty) import qualified Data.ByteString.Char8 as BC (unpack, pack) -import Storage.Hashed.Darcs( hashedTreeIO, readDarcsHashedNosize, readDarcsHashed,-                             writeDarcsHashed, readDarcsHashedDir, darcsLocation,+import Storage.Hashed.Darcs( readDarcsHashedDir, darcsLocation,                              decodeDarcsHash, decodeDarcsSize )-import Storage.Hashed.Tree( treeHash, ItemType(..) )-import Storage.Hashed.Hash( encodeBase16, Hash(..) )+import Storage.Hashed.Tree( ItemType(..) )+import Darcs.CommandsAux  -- | @readHashFile c subdir hash@ reads the file with hash @hash@ in dir subdir, -- fetching it from 'Cache' @c@ if needed.@@ -255,7 +254,10 @@           cp (F,n,h) = do ps <- readhash h                           lift $ finishedOneIO k (fn2fp n)                           lift $ writeAtomicFilePS (fn2fp n) ps-          cp (D,n,h) = do lift $ createDirectoryIfMissing False (fn2fp n)+          cp (D,n,h) = if isMaliciousSubPath (fn2fp n)+                          then fail ("Caught malicious path: " ++ fn2fp n)+                          else do+                          lift $ createDirectoryIfMissing False (fn2fp n)                           lift $ finishedOneIO k (fn2fp n)                           lift $ withCurrentDirectory (fn2fp n) $ copyHashed k c compr h @@ -287,8 +289,8 @@           listone h = do let size = decodeDarcsSize $ BC.pack h                              hash = decodeDarcsHash $ BC.pack h                          x <- readDarcsHashedDir hashdir (size, hash)-                         let subs = [ fst $ darcsLocation "" (s, h) | (TreeType, _, s, h) <- x ]-                             hashes = h : [ fst $ darcsLocation "" (s, h) | (_, _, s, h) <- x ]+                         let subs = [ fst $ darcsLocation "" (s, h') | (TreeType, _, s, h') <- x ]+                             hashes = h : [ fst $ darcsLocation "" (s, h') | (_, _, s, h') <- x ]                          (hashes++) . concat <$> mapM listone subs       hs <- set . concat <$> mapM listone hashroots       fs <- set . filter okayHash <$> getDirectoryContents hashdir
src/Darcs/Repository/Internal.hs view
@@ -22,7 +22,7 @@ #include "gadts.h"  module Darcs.Repository.Internal ( Repository(..), RepoType(..), RIO(unsafeUnRIO), ($-),-                    maybeIdentifyRepository, identifyDarcs1Repository, identifyRepositoryFor,+                    maybeIdentifyRepository, identifyDarcsRepository, identifyRepositoryFor,                     IdentifyRepo(..),                     findRepository, amInRepository, amNotInRepository,                     revertRepositoryChanges,@@ -195,6 +195,7 @@                              | NonRepository String -- ^ safest guess                              | GoodRepository (Repository p C(r u t)) +-- | Tries to identify the repository in a given directory maybeIdentifyRepository :: [DarcsFlag] -> String -> IO (IdentifyRepo p C(r u t)) maybeIdentifyRepository opts "." =     do darcs <- doesDirectoryExist darcsdir@@ -219,17 +220,22 @@                   Nothing ->  do cs <- getCaches opts url                                  return $ GoodRepository $ Repo url opts rf (DarcsRepository nopristine cs) -identifyDarcs1Repository :: [DarcsFlag] -> String -> IO (Repository Patch C(r u t))-identifyDarcs1Repository opts url =+-- | identifyDarcsRepository identifies the repo at 'url'. Warning:+-- you have to know what kind of patches are found in that repo.+identifyDarcsRepository :: forall p C(r u t). [DarcsFlag] -> String+                           -> IO (Repository p C(r u t))+identifyDarcsRepository opts url =     do er <- maybeIdentifyRepository opts url        case er of          BadRepository s -> fail s          NonRepository s -> fail s          GoodRepository r -> return r +-- | @identifyRepositoryFor repo url@ identifies (and returns) the repo at 'url',+-- but fails if it is not compatible for reading from and writing to. identifyRepositoryFor :: forall p C(r u t). RepoPatch p => Repository p C(r u t) -> String -> IO (Repository p C(r u t)) identifyRepositoryFor (Repo _ opts rf _) url =-    do Repo absurl _ rf_ t <- identifyDarcs1Repository opts url+    do Repo absurl _ rf_ t <- identifyDarcsRepository opts url        let t' = case t of DarcsRepository x c -> DarcsRepository x c        case readfromAndWritetoProblem rf_ rf of          Just e -> fail $ "Incompatibility with repository " ++ url ++ ":\n" ++ e@@ -441,7 +447,7 @@ checkUnrecordedConflicts :: forall p C(t y). RepoPatch p => [DarcsFlag] -> FL (Named p) C(t y) -> IO Bool checkUnrecordedConflicts opts _ | NoUpdateWorking `elem` opts = return False checkUnrecordedConflicts opts pc =-    do repository <- identifyDarcs1Repository opts "."+    do repository <- identifyDarcsRepository opts "."        cuc repository     where cuc :: Repository Patch C(r u t) -> IO Bool           cuc r = do Sealed mpend <- readPending r :: IO (Sealed (FL Prim C(t)))@@ -659,7 +665,7 @@ withRepositoryDirectory :: forall a. [DarcsFlag] -> String                         -> (forall p C(r u). RepoPatch p => Repository p C(r u r) -> IO a) -> IO a withRepositoryDirectory opts1 url job =-    do Repo dir opts rf rt <- identifyDarcs1Repository opts1 url+    do Repo dir opts rf rt <- identifyDarcsRepository opts1 url        let rt' = case rt of DarcsRepository t c -> DarcsRepository t c        if formatHas Darcs2 rf          then do debugMessage $ "Identified darcs-2 repo: " ++ dir
src/Darcs/Repository/Prefs.lhs view
@@ -448,25 +448,26 @@  setDefaultrepo :: String -> [DarcsFlag] -> IO () setDefaultrepo r opts =  do olddef <- getPreflist "defaultrepo"-                            let doit = NoSetDefault `notElem` opts && greenLight+                            let doit = null noSetDefault && greenLight                                 greenLight = wetRun                                            && not rIsTmp                                            && (olddef /= [r] || olddef == [])                             if doit                                then setPreflist "defaultrepo" [r]-                               else when greenLight $ putStr . unlines $+                               else when (True `notElem` noSetDefault && greenLight) $ putStr . unlines $                                       -- the nuance here is that we should only notify when the                                       -- reason we're not setting default is the --no-set-default                                       -- flag, not the various automatic show stoppers-                                      [ "Note: if you want to change the default remote repository to"-                                      , r ++ ","-                                      , "quit now and issue the same command with the --set-default flag."+                                      [ "HINT: if you want to change the default remote repository to"+                                      , "      " ++ r ++ ","+                                      , "      quit now and issue the same command with the --set-default flag."                                       ]                             addToPreflist "repos" r                          `catchall` return () -- we don't care if this fails!  where   wetRun = DryRun `notElem` opts   rIsTmp = r `elem` [x | RemoteRepo x <- opts]+  noSetDefault = [x | NoSetDefault x <- opts] \end{code}  \paragraph{email}
src/Darcs/SelectChanges.hs view
@@ -30,9 +30,10 @@ import Data.Maybe ( catMaybes, isJust, fromJust ) import Data.Char ( toUpper ) import Control.Monad ( when, (>=>) )+import Control.Monad.Identity ( Identity(..) ) import Control.Monad.Trans ( liftIO ) import Control.Monad.Reader ( ReaderT, Reader, asks, runReader, runReaderT )-import Control.Monad.State ( State(..), StateT, modify, gets, execStateT )+import Control.Monad.State ( StateT, modify, gets, runStateT, execStateT ) import System.Exit ( exitWith, ExitCode(ExitSuccess) )  import English ( Noun(..), englishNum  )@@ -313,7 +314,7 @@       o <- asks opts       if not $ isInteractive o        then return $ promote autoChoices-       else flip refineChoices autoChoices $ textSelect whch+       else refineChoices (textSelect whch) autoChoices     where forward = not $ backward whch           promote = if forward                     then makeEverythingSooner@@ -390,11 +391,11 @@  -- | Runs a function on the underlying @PatchChoices@ object liftChoices :: forall p a C(x y) . Patchy p =>-               State (PatchChoices p C(x y)) a+               StateT (PatchChoices p C(x y)) Identity a                    -> InteractiveSelectionM p C(x y) a liftChoices act = do   ch <- gets choices-  let (result, ch') = runState act ch+  let (result, ch') = runIdentity $ runStateT act ch   modify $ \isc -> isc {choices = ch}   return result 
src/Darcs/Test/Patch/Info.hs view
@@ -27,7 +27,7 @@ import qualified Data.ByteString.Char8 as BC ( unpack ) import Data.List ( sort ) import Data.Maybe ( isNothing )-import Data.Text as T ( findBy, any )+import Data.Text as T ( find, any ) import Data.Text.Encoding ( decodeUtf8With ) import Data.Text.Encoding.Error ( lenientDecode ) import Foreign ( unsafePerformIO )@@ -121,7 +121,7 @@        \patchInfo -> encodingOK (_piAuthor patchInfo)                      && encodingOK (_piName patchInfo)                      && all encodingOK (_piLog patchInfo)-  where encodingOK = isNothing . T.findBy (=='\xfffd') . decodeUtf8With lenientDecode+  where encodingOK = isNothing . T.find (=='\xfffd') . decodeUtf8With lenientDecode  -- | Test that metadata in patches are decoded as UTF-8 or locale depending on -- whether they're valid UTF-8.
src/Darcs/Test/Patch/QuickCheck.hs view
@@ -1,5 +1,5 @@ {-# OPTIONS_GHC -fno-warn-deprecations -fno-warn-orphans -fglasgow-exts #-}-{-# LANGUAGE CPP, UndecidableInstances, ScopedTypeVariables #-}+{-# LANGUAGE CPP, UndecidableInstances, ScopedTypeVariables, ViewPatterns #-}  #include "gadts.h" module Darcs.Test.Patch.QuickCheck ( WithStartState, RepoModel, Tree,@@ -308,18 +308,17 @@ propFail n xs = sizeTree xs < n  instance ArbitraryState s p => ArbitraryState s (WithState s p) where-  arbitraryState rm = do xandrm' <- arbitraryState rm-                         flip unseal xandrm' $ \(WithEndState x rm') ->-                           return $ seal $ WithEndState (WithState rm x rm') rm'+  arbitraryState rm = do Sealed (WithEndState x rm') <- arbitraryState rm+                         return $ seal $ WithEndState (WithState rm x rm') rm'  instance ArbitraryState s p => ArbitraryState s (FL p) where   arbitraryState rm1 = sized $ \n -> do k <- choose (0, n)                                         arbitraryList k rm1       where arbitraryList :: FORALL(x) Int -> s C(x) -> Gen (Sealed (WithEndState (FL p C(x)) s))             arbitraryList 0 rm = return $ seal $ WithEndState NilFL rm-            arbitraryList (n+1) rm = do Sealed (WithEndState x rm') <- arbitraryState rm-                                        Sealed (WithEndState xs rm'') <- arbitraryList n rm'-                                        return $ seal $ WithEndState (x :>: xs) rm''+            arbitraryList n rm = do Sealed (WithEndState x rm') <- arbitraryState rm+                                    Sealed (WithEndState xs rm'') <- arbitraryList (n-1) rm'+                                    return $ seal $ WithEndState (x :>: xs) rm''             arbitraryList _ _ = impossible  data Tree p C(x) where@@ -355,9 +354,8 @@ flattenTree :: (Commute p) => Tree p C(z) -> Sealed (G2 [] (FL p) C(z)) flattenTree NilTree = seal $ G2 $ return NilFL flattenTree (SeqTree p t) = mapSeal (G2 . map (p :>:) . unG2) $ flattenTree t-flattenTree (ParTree t1 t2) = flip unseal (flattenTree t1) $ \gpss1 ->-                              flip unseal (flattenTree t2) $ \gpss2 ->-                              seal $ G2 $+flattenTree (ParTree (flattenTree -> Sealed gpss1) (flattenTree -> Sealed gpss2))+                            = seal $ G2 $                               do ps1 <- unG2 gpss1                                  ps2 <- unG2 gpss2                                  ps2' :/\: ps1' <- return $ merge (ps1 :\/: ps2)@@ -441,7 +439,7 @@     | otherwise = (Hunk n (take pos' old ++ drop (pos'+1) old) new, Nothing)         where pos' = pos - n   shrinkPos _ _ = bug "foo1 in ShrinkablePos"-  shrinkPatch (Hunk (n+1) [] []) = [(Hunk n [] [], Nothing)]+  shrinkPatch (Hunk n [] []) | n > 0 = [(Hunk (n-1) [] [], Nothing)]   shrinkPatch (Hunk n old new)    = do i <- [0 .. length new - 1]         return (Hunk n old (take i new ++ drop (i+1) new), Just (n + i))@@ -508,10 +506,8 @@  flattenOne :: (FromPrim p, Commute p) => Tree Prim C(x) -> Sealed (FL p C(x)) flattenOne NilTree = seal NilFL-flattenOne (SeqTree p t) = flip unseal (flattenOne t) $ \ps -> seal (fromPrim p :>: ps)-flattenOne (ParTree t1 t2) =-    flip unseal (flattenOne t1) $ \ps1 ->-    flip unseal (flattenOne t2) $ \ps2 ->+flattenOne (SeqTree p (flattenOne -> Sealed ps)) = seal (fromPrim p :>: ps)+flattenOne (ParTree (flattenOne -> Sealed ps1) (flattenOne -> Sealed ps2)) =     --traceDoc (greenText "flattening two parallel series: ps1" $$ showPatch ps1 $$     --          greenText "ps2" $$ showPatch ps2) $     case merge (ps1 :\/: ps2) of
tests/external.sh view
@@ -31,7 +31,7 @@ cd .. darcs get temp1 > log not grep fakessh log-not darcs get http://example.com/foo+not darcs get http://darcs.net/nonexistent not grep fakessh log cd .. rm -rf temp1
+ tests/failing-issue2017-missing-tag.sh view
@@ -0,0 +1,85 @@+#!/usr/bin/env bash+## Test for issue2017 - apply should gracefully handle tag missing+## from context (complain, not crash)+##+## Copyright (C) 2010 Eric Kow+##+## Permission is hereby granted, free of charge, to any person+## obtaining a copy of this software and associated documentation+## files (the "Software"), to deal in the Software without+## restriction, including without limitation the rights to use, copy,+## modify, merge, publish, distribute, sublicense, and/or sell copies+## of the Software, and to permit persons to whom the Software is+## furnished to do so, subject to the following conditions:+##+## The above copyright notice and this permission notice shall be+## included in all copies or substantial portions of the Software.+##+## THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,+## EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF+## MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND+## NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS+## BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN+## ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN+## CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE+## SOFTWARE.++. lib                           # Load some portability helpers.+darcs init      --repo R        # Create our test repos.++cd R+echo 'Example content.' > f+darcs record -lam 'Add f'+cd ..++# variant 0 - this passes trivially+darcs get R R0+darcs get R0 S0+darcs tag 's' --repo S0+darcs get S0 T0+cd T0+echo 'More content.' > f+darcs record -lam 'Modify f'+darcs send -o foo.dpatch -a+cd ..+not darcs apply --repo R0 T0/foo.dpatch > log 2>&1+not grep bug log+grep missing log++# variant 1 - tag in shared context+darcs get R R1+darcs tag '1' --repo R1+darcs get R1 S1+darcs tag 's1' --repo S1+darcs get S1 T1+cd T1+echo 'More content.' > f+darcs record -lam 'Modify f'+darcs send -o foo.dpatch -a+cd ..+# sanity check: should be able to cherry pick+darcs get R1 R1b+cd R1b+[ `darcs changes --count` -eq 2 ]+darcs pull ../T1 --match 'touch f' --all+[ `darcs changes --count` -eq 3 ]+cd ..+# the test: can't apply this due to incorrect context+not darcs apply --repo R1 T1/foo.dpatch > log 2>&1+not grep 'bug' log+grep missing log++# variant 2 - tag created after the fact+darcs get R  R2+darcs get R2 S2+darcs tag 's2' --repo S2+darcs get S2 T2+cd T2+echo 'More content.' > f+darcs record -lam 'Modify f'+darcs send -o foo.dpatch -a+cd ..+darcs tag '2'  --repo R2  # only tag after+not darcs apply --repo R2 T2/foo.dpatch > log 2>&1+not grep 'bug' log+grep missing log
+ tests/failing-issue612_repo_not_writable.sh view
@@ -0,0 +1,39 @@+#!/usr/bin/env bash++# Test that darcs fails appropriately when the target repo inventory file is not writable.+# See issue612++. lib++abort_windows++if grep old-fashioned .darcs/defaults; then+  exit 200+fi++rm -rf temp1 temp2+mkdir temp1+cd temp1+darcs init+touch t.t+darcs add t.t+darcs record -am "initial add"+if [ -e _darcs/inventories ]; then+  chmod 0555 _darcs/inventories/*+  chmod 0555 _darcs/inventories+fi+if [ -e _darcs/inventory ]; then+  chmod 0555 _darcs/inventory+fi+cd ..++darcs get temp1 temp2+cd temp2+# this block may fail so we'd better make sure we clean up after+# ourselves to avoid a permissions mess for other tests+trap "cd ..; chmod -R 0755 temp1; rm -rf temp1 temp2" EXIT+echo new >> t.t+darcs record -am "new patch"+not darcs push -a ../temp1 2> log+grep failed log+
+ tests/hunk-editor.sh view
@@ -0,0 +1,46 @@+#!/usr/bin/env bash+## Test for hunk editor+##+## Copyright (C) 2011 Ganesh Sittampalam+##+## Permission is hereby granted, free of charge, to any person+## obtaining a copy of this software and associated documentation+## files (the "Software"), to deal in the Software without+## restriction, including without limitation the rights to use, copy,+## modify, merge, publish, distribute, sublicense, and/or sell copies+## of the Software, and to permit persons to whom the Software is+## furnished to do so, subject to the following conditions:+##+## The above copyright notice and this permission notice shall be+## included in all copies or substantial portions of the Software.+##+## THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,+## EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF+## MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND+## NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS+## BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN+## ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN+## CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE+## SOFTWARE.++. lib                           # Load some portability helpers.+rm -rf R                        # Another script may have left a mess.++darcs init      --repo R++cd R++echo 'version1' > file+darcs record -lam "version1"++echo 'version2' > file+(echo e ; echo y ; echo n) | DARCS_EDITOR="sed -i -e s/version2/version1.5/" darcs record -m "version1.5"++cat > expected <<EOF+hunk ./file 1+-version1.5++version2+EOF++darcs whatsnew | diff -u expected -+
+ tests/issue1978.sh view
@@ -0,0 +1,35 @@+#!/usr/bin/env bash++. lib++mkdir future+cd future+darcs  init+touch titi+darcs add titi+darcs record -am titi+cat > _darcs/format <<EOF+hashed|gobbledygook+darcs-2+EOF+cat _darcs/format+cd ..++if grep 'old-fashioned' .darcs/defaults; then+    exit 200+fi++if grep hashed .darcs/defaults; then+    exit 200+fi++# get future repo: should be ok+darcs get future temp1+cd temp1+darcs changes+touch toto+darcs add toto+darcs record -am 'blah'+cd ..+rm -rf temp1 future+
+ tests/issue2035-malicious-subpath.sh view
@@ -0,0 +1,30 @@+#!/usr/bin/env bash+## Test for issue2035 - malicious subpaths+##+## Copyright (C) 2010 Eric Kow <kowey@darcs.net>+##+## Permission is hereby granted, free of charge, to any person+## obtaining a copy of this software and associated documentation+## files (the "Software"), to deal in the Software without+## restriction, including without limitation the rights to use, copy,+## modify, merge, publish, distribute, sublicense, and/or sell copies+## of the Software, and to permit persons to whom the Software is+## furnished to do so, subject to the following conditions:+##+## The above copyright notice and this permission notice shall be+## included in all copies or substantial portions of the Software.+##+## THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,+## EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF+## MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND+## NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS+## BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN+## ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN+## CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE+## SOFTWARE.++TESTDATA=repos # remove this line in HEAD++. lib                  # Load some portability helpers.+tar zxf $TESTDATA/badrepo.tgz+not darcs get badrepo
− tests/issue612_repo_not_writeable.sh
@@ -1,42 +0,0 @@-#!/usr/bin/env bash--# Test that darcs fails appropriately when the target repo inventory file is not writable.-# See issue612--. lib--abort_windows--if grep old-fashioned .darcs/defaults; then-  echo This test does not work with old-fashioned inventories-  exit 0-fi--rm -rf temp1 temp2-mkdir temp1-cd temp1-darcs init-touch t.t-darcs add t.t-darcs record -am "initial add"-if [ -e _darcs/inventories ]; then-  chmod 0555 _darcs/inventories/*-  chmod 0555 _darcs/inventories-fi-if [ -e _darcs/inventory ]; then-  chmod 0555 _darcs/inventory-fi-cd ..--darcs get temp1 temp2-cd temp2-echo new >> t.t-darcs record -am "new patch"-not darcs push -a ../r1 2> log-grep failed log-cd ..--chmod -R 0755 temp1-rm -rf temp1 temp2--
tests/lib view
@@ -13,7 +13,7 @@ }  pwd() {-    ghc --make "$TESTS_WD/hspwd.hs"+    ghc --make "$TESTS_WD/hspwd.hs" > /dev/null     "$TESTS_WD/hspwd" } 
tests/repoformat.sh view
@@ -2,13 +2,117 @@  . lib -rm -rf temp1 temp2-mkdir temp1-cd temp1+rm -rf garbage future+mkdir garbage+cd garbage darcs  init echo gobbledygook > _darcs/format cd .. -not darcs get temp1 temp2 2> log+mkdir future+cd future+darcs  init+touch titi+darcs add titi+darcs record -am titi+cat > _darcs/format <<EOF+hashed|gobbledygook+darcs-2+EOF+cd ..+++# check the rules for reading and writing++## garbage repo: we don't understand anything+# get garbage repo+not darcs get garbage temp1 2> log grep -i "can't understand repository format" log-rm -rf temp1 temp2 log+rm -rf temp1 log++# pull from garbage repo+mkdir temp1+cd temp1+darcs init+not darcs pull ../garbage 2> log+grep -i "can't understand repository format" log+cd ..+rm -rf temp1++# apply in garbage repo+mkdir temp1+cd temp1+darcs init+darcs changes --context > empty-context+darcs tag -m "just a patch"+darcs send -a --context=empty-context -o ../bundle.dpatch .+cd ../garbage+not darcs apply ../bundle.dpatch 2> log+grep -i "can't understand repository format" log+cd ..+rm -rf temp1 bundle.dpatch++# add in garbage repo+cd garbage+touch toto+not darcs add toto 2> log+grep -i "can't understand repository format" log+cd ..++rm -rf garbage+++## future repo: we don't understand one+#  alternative of a line of format+#  only look at future vs darcs2++if grep 'old-fashioned' .darcs/defaults; then+    exit 200+fi++if grep hashed .darcs/defaults; then+    exit 200+fi++# get future repo: ok+# --to-match is needed because of bug###+darcs get future temp1 --to-match "name titi"+cd temp1+darcs changes+touch toto+darcs add toto+darcs record -am 'blah'+cd ..+rm -rf temp1++# pull from future repo: ok+mkdir temp1+cd temp1+darcs init+darcs pull ../future -a+darcs cha | grep titi+cd ..+rm -rf temp1++# apply in future repo: !ok+mkdir temp1+cd temp1+darcs init+darcs changes --context > empty-context+darcs tag -m "just a patch"+darcs send -a --context=empty-context -o ../bundle.dpatch .+cd ../future+not darcs apply ../bundle.dpatch 2> log+cat log+grep -i "can't write repository format" log+cd ..+rm -rf temp1 bundle.dpatch++# record in future repo: !ok+cd future+touch toto+not darcs add toto 2> log+grep -i "can't write repository format" log+cd ..++rm -rf future #No future!
+ tests/repos/badrepo.tgz view

binary file changed (absent → 3537 bytes)

+ tests/set-default-hint.sh view
@@ -0,0 +1,51 @@+#!/usr/bin/env bash+## Test that set-default hint messages are produced at the right times+##+## Copyright (C) 2011 Ganesh Sittampalam+##+## Permission is hereby granted, free of charge, to any person+## obtaining a copy of this software and associated documentation+## files (the "Software"), to deal in the Software without+## restriction, including without limitation the rights to use, copy,+## modify, merge, publish, distribute, sublicense, and/or sell copies+## of the Software, and to permit persons to whom the Software is+## furnished to do so, subject to the following conditions:+##+## The above copyright notice and this permission notice shall be+## included in all copies or substantial portions of the Software.+##+## THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,+## EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF+## MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND+## NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS+## BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN+## ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN+## CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE+## SOFTWARE.++. lib                           # Load some portability helpers.+rm -rf R1 R2 R3                 # Another script may have left a mess.++darcs init      --repo R1+darcs get R1 R2+darcs get R1 R3++HINTSTRING="issue the same command with the --set-default flag"++cd R3+for command in pull push send+do+   # R1 should be the default for R3+   darcs $command ../R1 | not grep "$HINTSTRING"+   darcs $command ../R2 | grep "$HINTSTRING"++   # can disable message on the command-line+   darcs $command --no-set-default ../R2 | not grep "$HINTSTRING"++   # or using defaults+   echo "$command no-set-default" >> ../.darcs/defaults+   darcs $command ../R2 | not grep "$HINTSTRING"++   darcs $command --set-default ../R2 | not grep "$HINTSTRING"+   darcs $command --set-default ../R1 | not grep "$HINTSTRING"+done