Darcs.Patch.Prim

Documentation

data Prim where

Constructors

Move :: !FileName -> !FileName -> Prim

DP :: !FileName -> !DirPatchType -> Prim

FP :: !FileName -> !FilePatchType -> Prim

Split :: FL Prim -> Prim

Identity :: Prim

ChangePref :: !String -> !String -> !String -> Prim

Instances

Show Prim

Show2 Prim

MyEq Prim

Invert Prim

ReadPatch Prim

ShowPatch Prim

Commute Prim

Apply Prim

Patchy Prim

Effect Prim

Conflict Prim

ToFromPrim Prim

FromPrim Prim

Nonable Prim

data IsConflictedPrim where

Constructors

IsC :: !ConflictState -> !Prim -> IsConflictedPrim

data ConflictState

Constructors

Okay

Conflicted

Duplicated

Instances

Eq ConflictState

Ord ConflictState

Read ConflictState

Show ConflictState

showPrim :: FileNameFormat -> Prim -> Doc

showPrimFL :: FileNameFormat -> FL Prim -> Doc

showHunk :: FileNameFormat -> FileName -> Int -> [ByteString] -> [ByteString] -> Doc

data DirPatchType

Constructors

RmDir

AddDir

Instances

Eq DirPatchType

Ord DirPatchType

Show DirPatchType

MyEq DirPatchType

data FilePatchType

Constructors

RmFile

AddFile

Hunk !Int [ByteString] [ByteString]

TokReplace !String !String !String

Binary ByteString ByteString

Instances

Eq FilePatchType

Ord FilePatchType

Show FilePatchType

MyEq FilePatchType

type CommuteFunction = (Prim :< Prim) -> Perhaps (Prim :< Prim)

data Perhaps a

Constructors

Unknown

Failed

Succeeded a

Instances

Monad Perhaps

MonadPlus Perhaps

null_patch :: Prim

nullP :: Prim -> EqCheck

isNullPatch :: Prim -> Bool

isIdentity :: Prim -> EqCheck

formatFileName :: FileNameFormat -> FileName -> Doc

data FileNameFormat

Constructors

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

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 -> 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

sortCoalesceFL ps coalesces as many patches in ps as possible, sorting the results according to the scheme defined in comparePrim

join :: (Prim :> Prim) -> Maybe Prim

canonizeFL :: FL Prim -> FL Prim

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]

tryShrinkingInverse :: FL Prim -> Maybe (FL Prim)

nFn :: FilePath -> FilePath

class FromPrim p where

Methods

fromPrim :: Prim -> p

Instances

FromPrim Prim

FromPrim Patch

FromPrim RealPatch

class FromPrims p where

Methods

fromPrims :: FL Prim -> p

joinPatches :: FL p -> p

Instances

FromPrims Patch

FromPrim p => FromPrims (RL p)

FromPrim p => FromPrims (FL p)

class FromPrim p => ToFromPrim p where

Methods

toPrim :: p -> Maybe Prim

Instances

ToFromPrim Prim

ToFromPrim RealPatch

class (Invert p, Commute p, Effect p) => Conflict p where

Methods

listConflictedFiles :: p -> [FilePath]

resolveConflicts :: p -> [[Sealed (FL Prim)]]

commuteNoConflicts :: (p :> p) -> Maybe (p :> p)

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]

isInconsistent :: p -> Maybe Doc

Instances

Conflict Prim

Conflict Patch

Conflict RealPatch

Conflict p => Conflict (RL p)

Conflict p => Conflict (FL p)

Conflict p => Conflict (Named p)

Conflict p => Conflict (PatchInfoAnd p)

class Effect p where

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 Prim

effectRL :: p -> RL Prim

isHunk :: p -> Maybe Prim

Instances

Effect Prim

Effect Patch

Effect RealPatch

Effect p => Effect (RL p)

Effect p => Effect (FL p)

Effect p => Effect (Named p)

Effect p => Effect (PatchInfoAnd p)

commuteNoConflictsFL :: Conflict p => (p :> FL p) -> Maybe (FL p :> p)

commuteNoConflictsRL :: Conflict p => (RL p :> p) -> Maybe (p :> RL p)