darcs-2.5.2: a distributed, interactive, smart revision control system

Darcs.Patch.Prim

Synopsis

Documentation

data IsConflictedPrim where

Constructors

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

data Perhaps a

Constructors

Unknown 
Failed 
Succeeded a 

data FileNameFormat

Constructors

OldFormat 
NewFormat 

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.

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

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

class FromPrim p where

Methods

fromPrim :: Prim -> p

class FromPrims p where

Methods

fromPrims :: FL Prim -> p

joinPatches :: FL p -> p

Instances

class FromPrim p => ToFromPrim p where

Methods

toPrim :: p -> Maybe Prim

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

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

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

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