darcs-beta-2.4.98.5: a distributed, interactive, smart revision control systemSource codeContentsIndex
Darcs.Patch.Prim
Synopsis
data Prim where
Move :: !FileName -> !FileName -> Prim
DP :: !FileName -> !DirPatchType -> Prim
FP :: !FileName -> !FilePatchType -> Prim
Split :: FL Prim -> Prim
Identity :: Prim
ChangePref :: !String -> !String -> !String -> Prim
data IsConflictedPrim where
IsC :: !ConflictState -> !Prim -> IsConflictedPrim
data ConflictState
= Okay
| Conflicted
| Duplicated
showPrim :: FileNameFormat -> Prim -> Doc
showPrimFL :: FileNameFormat -> FL Prim -> Doc
showHunk :: FileNameFormat -> FileName -> Int -> [ByteString] -> [ByteString] -> Doc
data DirPatchType
= RmDir
| AddDir
data FilePatchType
= RmFile
| AddFile
| Hunk !Int [ByteString] [ByteString]
| TokReplace !String !String !String
| Binary ByteString ByteString
type CommuteFunction = (Prim :< Prim) -> Perhaps (Prim :< Prim)
data Perhaps a
= Unknown
| Failed
| Succeeded a
null_patch :: Prim
nullP :: Prim -> EqCheck
isNullPatch :: Prim -> Bool
isIdentity :: Prim -> EqCheck
formatFileName :: FileNameFormat -> FileName -> Doc
data FileNameFormat
= OldFormat
| NewFormat
adddir :: FilePath -> Prim
addfile :: FilePath -> Prim
binary :: FilePath -> ByteString -> ByteString -> Prim
changepref :: String -> String -> String -> Prim
hunk :: FilePath -> Int -> [ByteString] -> [ByteString] -> Prim
move :: FilePath -> FilePath -> Prim
rmdir :: FilePath -> Prim
rmfile :: FilePath -> Prim
tokreplace :: FilePath -> String -> String -> String -> Prim
primIsAddfile :: Prim -> Bool
primIsHunk :: Prim -> Bool
primIsBinary :: Prim -> Bool
primIsSetpref :: Prim -> Bool
isSimilar :: Prim -> Prim -> Bool
primIsAdddir :: Prim -> Bool
is_filepatch :: Prim -> Maybe FileName
canonize :: Prim -> FL Prim
tryToShrink :: FL Prim -> FL Prim
modernizePrim :: Prim -> FL Prim
subcommutes :: [(String, (Prim :< Prim) -> Perhaps (Prim :< Prim))]
sortCoalesceFL :: FL Prim -> FL Prim
join :: (Prim :> Prim) -> Maybe Prim
canonizeFL :: FL Prim -> FL Prim
tryTokInternal :: String -> ByteString -> ByteString -> ByteString -> Maybe [ByteString]
tryShrinkingInverse :: FL Prim -> Maybe (FL Prim)
nFn :: FilePath -> FilePath
class FromPrim p where
fromPrim :: Prim -> p
class FromPrims p where
fromPrims :: FL Prim -> p
joinPatches :: FL p -> p
class FromPrim p => ToFromPrim p where
toPrim :: p -> Maybe Prim
class (Invert p, Commute p, Effect p) => Conflict p where
listConflictedFiles :: p -> [FilePath]
resolveConflicts :: p -> [[Sealed (FL Prim)]]
commuteNoConflicts :: (p :> p) -> Maybe (p :> p)
conflictedEffect :: p -> [IsConflictedPrim]
isInconsistent :: p -> Maybe Doc
class Effect p where
effect :: p -> FL Prim
effectRL :: p -> RL Prim
isHunk :: p -> Maybe Prim
commuteNoConflictsFL :: Conflict p => (p :> FL p) -> Maybe (FL p :> p)
commuteNoConflictsRL :: Conflict p => (RL p :> p) -> Maybe (p :> RL p)
Documentation
data Prim whereSource
Constructors
Move :: !FileName -> !FileName -> Prim
DP :: !FileName -> !DirPatchType -> Prim
FP :: !FileName -> !FilePatchType -> Prim
Split :: FL Prim -> Prim
Identity :: Prim
ChangePref :: !String -> !String -> !String -> Prim
show/hide Instances
data IsConflictedPrim whereSource
Constructors
IsC :: !ConflictState -> !Prim -> IsConflictedPrim
data ConflictState Source
Constructors
Okay
Conflicted
Duplicated
show/hide Instances
showPrim :: FileNameFormat -> Prim -> DocSource
showPrimFL :: FileNameFormat -> FL Prim -> DocSource
showHunk :: FileNameFormat -> FileName -> Int -> [ByteString] -> [ByteString] -> DocSource
data DirPatchType Source
Constructors
RmDir
AddDir
show/hide Instances
data FilePatchType Source
Constructors
RmFile
AddFile
Hunk !Int [ByteString] [ByteString]
TokReplace !String !String !String
Binary ByteString ByteString
show/hide Instances
type CommuteFunction = (Prim :< Prim) -> Perhaps (Prim :< Prim)Source
data Perhaps a Source
Constructors
Unknown
Failed
Succeeded a
show/hide Instances
null_patch :: PrimSource
nullP :: Prim -> EqCheckSource
isNullPatch :: Prim -> BoolSource
isIdentity :: Prim -> EqCheckSource
formatFileName :: FileNameFormat -> FileName -> DocSource
data FileNameFormat Source
Constructors
OldFormat
NewFormat
adddir :: FilePath -> PrimSource
addfile :: FilePath -> PrimSource
binary :: FilePath -> ByteString -> ByteString -> PrimSource
changepref :: String -> String -> String -> PrimSource
hunk :: FilePath -> Int -> [ByteString] -> [ByteString] -> PrimSource
move :: FilePath -> FilePath -> PrimSource
rmdir :: FilePath -> PrimSource
rmfile :: FilePath -> PrimSource
tokreplace :: FilePath -> String -> String -> String -> PrimSource
primIsAddfile :: Prim -> BoolSource
primIsHunk :: Prim -> BoolSource
primIsBinary :: Prim -> BoolSource
primIsSetpref :: Prim -> BoolSource
isSimilar :: Prim -> Prim -> BoolSource
Tells you if two patches are in the same category, human-wise. Currently just returns true if they are filepatches on the same file.
primIsAdddir :: Prim -> BoolSource
is_filepatch :: Prim -> Maybe FileNameSource
canonize :: Prim -> FL PrimSource
tryToShrink :: FL Prim -> FL PrimSource
modernizePrim :: Prim -> FL PrimSource
subcommutes :: [(String, (Prim :< Prim) -> Perhaps (Prim :< Prim))]Source
sortCoalesceFL :: FL Prim -> FL PrimSource
sortCoalesceFL ps coalesces as many patches in ps as possible, sorting the results according to the scheme defined in comparePrim
join :: (Prim :> Prim) -> Maybe PrimSource
canonizeFL :: FL Prim -> FL PrimSource

canonizeFL ps puts a sequence of primitive patches into canonical form. Even if the patches are just hunk patches, this is not necessarily the same set of results as you would get if you applied the sequence to a specific tree and recalculated a diff.

Note that this process does not preserve the commutation behaviour of the patches and is therefore not appropriate for use when working with already recorded patches (unless doing amend-record or the like).

tryTokInternal :: String -> ByteString -> ByteString -> ByteString -> Maybe [ByteString]Source
tryShrinkingInverse :: FL Prim -> Maybe (FL Prim)Source
nFn :: FilePath -> FilePathSource
class FromPrim p whereSource
Methods
fromPrim :: Prim -> pSource
show/hide Instances
class FromPrims p whereSource
Methods
fromPrims :: FL Prim -> pSource
joinPatches :: FL p -> pSource
show/hide Instances
class FromPrim p => ToFromPrim p whereSource
Methods
toPrim :: p -> Maybe PrimSource
show/hide Instances
class (Invert p, Commute p, Effect p) => Conflict p whereSource
Methods
listConflictedFiles :: p -> [FilePath]Source
resolveConflicts :: p -> [[Sealed (FL Prim)]]Source
commuteNoConflicts :: (p :> p) -> Maybe (p :> p)Source

If commuteNoConflicts x :> y succeeds, we know that that x commutes past y without any conflicts. This function is useful for patch types for which commute is defined to always succeed; so we need some way to pick out the specific cases where commutation succeeds without any conflicts.

Consider the commute square with patch names written in capital letters and repository states written in small letters.

          X
       o-->--a
       |     |
    Y' v     v Y
       |     |
       z-->--b
          X'

The default definition of this function checks that we can mirror the commutation with patch inverses (written with the negative sign)

         -X     X
       a-->--o-->--a
       |     |     |
   Y'' v  Y' v     v Y
       |     |     |
       b-->--z-->--b
         (-X)'  X'

We check that commuting X and Y succeeds, as does commuting -X and Y'. It also checks that Y'' == Y and that -(X') is the same as (-X)'

conflictedEffect :: p -> [IsConflictedPrim]Source
isInconsistent :: p -> Maybe DocSource
show/hide Instances
class Effect p whereSource

Patches whose concrete effect which can be expressed as a list of primitive patches.

A minimal definition would be either of effect or effectRL.

Methods
effect :: p -> FL PrimSource
effectRL :: p -> RL PrimSource
isHunk :: p -> Maybe PrimSource
show/hide Instances
commuteNoConflictsFL :: Conflict p => (p :> FL p) -> Maybe (FL p :> p)Source
commuteNoConflictsRL :: Conflict p => (RL p :> p) -> Maybe (p :> RL p)Source
Produced by Haddock version 2.6.1