darcs

Darcs.Patch

Synopsis

Documentation

class (Patchy p, Effect p, FromPrims p, Conflict p) => RepoPatch p

Instances

RepoPatch Patch 
RepoPatchBase p => RepoPatch (FL p) 

data RealPatch

Duplicate x: This patch has no effect since x is already present in the repository

Etacilpud x: invert (Duplicate x)

Normal prim: A primitive patch

Conflictor ix xx x: ix is the set of patches:

  • that conflict with x and also conflict with another patch in the repository
  • that conflict with a patch that conflict with x

xx is the sequence of patches that conflict *only* with x

x is the current patch

ix and x are stored as Non objects, which include any necessary context to uniquely define the patch that is referred to.

InvConflictor ix xx x: like invert (Conflictor ix xx x)

data Named p

The Named type adds a patch info about a patch, that is a name.

NamedP info deps p represents patch p with name info. deps is a list of dependencies added at the named patch level, compared with the unnamed level (ie, dependencies added with darcs record --ask-deps).

Instances

(Conflict p, ShowPatch p) => Show (Named p) 
MyEq p => MyEq (Named p) 
Invert p => Invert (Named p) 
ReadPatch p => ReadPatch (Named p) 
(Conflict p, ShowPatch p) => ShowPatch (Named p) 
Commute p => Commute (Named p) 
Apply p => Apply (Named p) 
(Conflict p, Effect p, Patchy p) => Patchy (Named p) 
Effect p => Effect (Named p) 
Conflict p => Conflict (Named p) 

class (Apply p, Commute p, ShowPatch p, ReadPatch p, Invert p) => Patchy p

Instances

joinPatches :: FromPrims p => FL p -> p

fromPrim :: FromPrim p => Prim -> p

fromPrims :: FromPrims p => FL Prim -> p

namepatch :: Patchy p => String -> String -> String -> [String] -> p -> IO (Named p)

anonymous :: Patchy p => p -> IO (Named p)

showContextPatch :: ShowPatch p => p -> TreeIO Doc

showPatch :: ShowPatch p => p -> Doc

showNicely :: ShowPatch p => p -> Doc

infopatch :: Patchy p => PatchInfo -> p -> Named p

thing :: ShowPatch p => p -> String

things :: ShowPatch p => p -> String

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.

merge :: Commute p => (p :\/: p) -> p :/\: p

commute :: Commute p => (p :> p) -> Maybe (p :> p)

hunkMatches :: Commute p => (ByteString -> Bool) -> p -> Bool

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

Instances

invert :: Invert p => p -> p

invertFL :: Invert p => FL p -> RL p

invertRL :: Invert p => RL p -> FL p

identity :: Invert p => p

commuteFLorComplain :: Commute p => (p :> FL p) -> Either (Sealed2 p) (FL p :> p)

commuteRL :: Commute p => (RL p :> p) -> Maybe (p :> RL p)

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

apply :: (Apply p, WriteableDirectory m) => [DarcsFlag] -> p -> m ()

applyToTree :: Apply p => p -> Tree IO -> IO (Tree IO)

Apply a patch to a Tree, yielding a new Tree.

summary :: ShowPatch p => p -> Doc

plainSummary :: (Conflict e, Effect e) => e -> Doc

xmlSummary :: (Effect p, Patchy p, Conflict p) => Named p -> Doc

adddeps :: Named p -> [PatchInfo] -> Named p

modernizePatch :: Patch -> Patch

modernizePatch is used during conversion to Darcs 2 format. It does the following:

  • removes mergers by linearising them, thus removing the ability to commute them
  • drops mv a b ; add b which was introduced by an error in earlier versions of darcs (TODO: check this; identify the versions)