-- Copyright (C) 2002-2004 David Roundy
--
-- This program is free software; you can redistribute it and/or modify
-- it under the terms of the GNU General Public License as published by
-- the Free Software Foundation; either version 2, or (at your option)
-- any later version.
--
-- This program is distributed in the hope that it will be useful,
-- but WITHOUT ANY WARRANTY; without even the implied warranty of
-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-- GNU General Public License for more details.
--
-- You should have received a copy of the GNU General Public License
-- along with this program; see the file COPYING. If not, write to
-- the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
-- Boston, MA 02110-1301, USA.
-- | The purpose of this module is to deal with many of the common
-- cases that come up when choosing a subset of a group of patches.
--
-- The idea is to divide a sequence of candidate patches into an initial
-- section named 'InFirst', a final section named 'InLast', and between them a
-- third section of not yet decided patches named 'InMiddle'. The reason for the
-- neutral terminology 'InFirst', 'InMiddle', and 'InLast', is that which of 'InFirst'
-- and 'InLast' counts as @selected@ or @deselected@ depends on
-- what we want to achive, that is, on the command and its options.
-- See "Darcs.UI.SelectChanges" for examples of how to use the functions from
-- this module.
--
-- Obviously if there are dependencies between the patches that will put a
-- constraint on how you can choose to divide them up. Unless stated otherwise,
-- functions that move patches from one section to another pull all dependent
-- patches with them.
--
-- Internally, we don't necessarily reorder patches immediately, but merely
-- tag them with the desired status, and thus postpone the actual commutation.
-- This saves a lot of unnecessary work, especially when choices are made
-- interactively, where the user can revise earlier decisions.
module Darcs.Patch.Choices
( -- * Choosing patches
PatchChoices
, Slot(..)
-- ** Constructing
, patchChoices
, mkPatchChoices
-- ** Querying
, patchSlot
, getChoices
, separateFirstMiddleFromLast
, separateFirstFromMiddleLast
-- ** Forcing patches into a given 'Slot'
, forceMatchingFirst
, forceFirsts
, forceFirst
, forceMatchingLast
, forceLasts
, forceLast
, forceMiddle
, makeEverythingSooner
, makeEverythingLater
-- ** Operations on 'InMiddle' patches
, selectAllMiddles
, refineChoices
-- ** Substitution
, substitute
-- * Labelling patches
, LabelledPatch
, Label
, label
, unLabel
, labelPatches
, getLabelInt
) where
import Prelude ()
import Darcs.Prelude
import Darcs.Patch.Merge ( Merge, merge )
import Darcs.Patch.Invert ( Invert, invert )
import Darcs.Patch.Commute ( Commute, commute, commuteRL )
import Darcs.Patch.Inspect ( PatchInspect, listTouchedFiles, hunkMatches )
import Darcs.Patch.Permutations ( commuteWhatWeCanRL, commuteWhatWeCanFL )
import Darcs.Patch.Witnesses.Eq ( Eq2(..), EqCheck(..) )
import Darcs.Patch.Witnesses.Ordered
( FL(..), RL(..)
, (:>)(..), (:\/:)(..), (:/\:)(..), (:||:)(..)
, zipWithFL, mapFL_FL, concatFL
, (+>+), reverseRL, anyFL )
import Darcs.Patch.Witnesses.Sealed ( Sealed2(..) )
import Darcs.Patch.Witnesses.Unsafe ( unsafeCoerceP )
-- | 'Label' @mp i@ acts as a temporary identifier to help us keep track of patches
-- during the selection process. These are useful for finding patches that
-- may have moved around during patch selection (being pushed forwards or
-- backwards as dependencies arise).
--
-- The identifier is implemented as a tuple @Label mp i@. The @i@ is an
-- integer, expected to be unique within the patches being
-- scrutinised. The @mp@ is motivated by patch splitting; it
-- provides a convenient way to generate a new identifier from the patch
-- being split. For example, if we split a patch identified as @Label Nothing
-- 5@, the resulting sub-patches could be identified as
-- @Label (Just (Label Nothing 5))1@, @Label (Just (Label Nothing 5)) 2@, etc.
--
-- IOW, 'Label' is a non-empty, reversed list of 'Int's.
data Label = Label (Maybe Label) Int deriving Eq
-- | A patch with a 'Label' attached to it.
data LabelledPatch p wX wY = LP Label (p wX wY)
-- | This internal type tags a 'LabelledPatch' with a 'Bool', to distinguish
-- 'InMiddle' from 'InLast' patches.
data PatchChoice p wX wY = PC
{ pcPatch :: (LabelledPatch p wX wY) -- ^ the 'LabelledPatch' in question
, _pcIsLast :: Bool -- ^ 'False' = 'InMiddle', 'True' = 'InLast'
}
-- | Internal function to tag a 'LabelledPatch' as 'InMiddle' or 'InLast'.
pcSetLast :: Bool -> LabelledPatch p wX wY -> PatchChoice p wX wY
pcSetLast = flip PC
-- TODO pcsFirsts should be an 'RL', not an 'FL'.
-- | A sequence of 'LabelledPatch'es where each patch is either
-- 'InFirst', 'InMiddle', or 'InLast'. The representation is
-- optimized for the case where we start chosing patches from the left
-- of the sequence: patches that are 'InFirst' are commuted to the head
-- immediately, but patches that are 'InMiddle' or 'InLast' are mixed
-- together; when a patch is marked 'InLast', its dependencies are
-- not updated until we retrieve the final result.
data PatchChoices p wX wY where
PCs :: { pcsFirsts :: FL (LabelledPatch p) wX wM
, pcsMiddleLasts :: FL (PatchChoice p) wM wY}
-> PatchChoices p wX wY
-- | See module documentation for "Darcs.Patch.Choices".
data Slot = InFirst | InMiddle | InLast
label :: LabelledPatch p wX wY -> Label
label (LP tg _) = tg
getLabelInt :: Label -> Int
getLabelInt (Label _ i) = i
unLabel :: LabelledPatch p wX wY -> p wX wY
unLabel (LP _ p) = p
-- This is dangerous if two patches from different labelled series are compared
-- ideally Label (and hence LabelledPatch/PatchChoices) would have a witness type
-- to represent the originally labelled sequence.
compareLabels :: LabelledPatch p wA wB -> LabelledPatch p wC wD -> EqCheck (wA, wB) (wC, wD)
compareLabels (LP l1 _) (LP l2 _) = if l1 == l2 then unsafeCoerceP IsEq else NotEq
instance Eq2 p => Eq2 (LabelledPatch p) where
unsafeCompare (LP l1 p1) (LP l2 p2) = l1 == l2 && unsafeCompare p1 p2
instance Invert p => Invert (LabelledPatch p) where
invert (LP t p) = LP t (invert p)
instance Commute p => Commute (LabelledPatch p) where
commute (LP l1 p1 :> LP l2 p2) = do
p2' :> p1' <- commute (p1 :> p2)
return (LP l2 p2' :> LP l1 p1')
instance PatchInspect p => PatchInspect (LabelledPatch p) where
listTouchedFiles = listTouchedFiles . unLabel
hunkMatches f = hunkMatches f . unLabel
instance Merge p => Merge (LabelledPatch p) where
merge (LP l1 p1 :\/: LP l2 p2) =
case merge (p1 :\/: p2) of
p2' :/\: p1' -> LP l2 p2' :/\: LP l1 p1'
instance Commute p => Commute (PatchChoice p) where
commute (PC p1 c1 :> PC p2 c2) = do
p2' :> p1' <- commute (p1 :> p2)
return (PC p2' c2 :> PC p1' c1)
instance PatchInspect p => PatchInspect (PatchChoice p) where
listTouchedFiles = listTouchedFiles . pcPatch
hunkMatches f = hunkMatches f . pcPatch
instance Merge p => Merge (PatchChoice p) where
merge (PC lp1 c1 :\/: PC lp2 c2) = case merge (lp1 :\/: lp2) of
lp2' :/\: lp1' -> PC lp2' c2 :/\: PC lp1' c1
-- | Create a 'PatchChoices' from a sequence of patches, so that
-- all patches are initially 'InMiddle'.
patchChoices :: FL p wX wY -> PatchChoices p wX wY
patchChoices = mkPatchChoices . labelPatches Nothing
-- | Label a sequence of patches, maybe using the given parent label.
labelPatches :: Maybe Label -> FL p wX wY -> FL (LabelledPatch p) wX wY
labelPatches tg ps = zipWithFL LP (map (Label tg) [1..]) ps
-- | Create a 'PatchChoices' from an already labelled sequence of patches,
-- so that all patches are initially 'InMiddle'.
mkPatchChoices :: FL (LabelledPatch p) wX wY -> PatchChoices p wX wY
mkPatchChoices = PCs NilFL . mapFL_FL (pcSetLast False)
instance Eq2 p => Eq2 (PatchChoice p) where
unsafeCompare (PC lp1 _) (PC lp2 _) = unsafeCompare lp1 lp2
-- | Like 'getChoices' but lumps together 'InMiddle' and 'InLast' patches.
-- This is more efficient than using 'getChoices' and then catenating 'InMiddle'
-- and 'InLast' sections because we have to commute less.
-- (This is what 'PatchChoices' are optimized for.)
--
-- prop> separateFirstFromMiddleLast c == case getChoices c of f:>m:>l -> f:>m+>+l
separateFirstFromMiddleLast :: PatchChoices p wX wZ
-> (FL (LabelledPatch p) :> FL (LabelledPatch p)) wX wZ
separateFirstFromMiddleLast (PCs f ml) = f :> mapFL_FL pcPatch ml
-- | Like 'getChoices' but lumps together 'InFirst' and 'InMiddle' patches.
--
-- prop> separateFirstMiddleFromLast c == case getChoices c of f:>m:>l -> f+>+m:>l
separateFirstMiddleFromLast :: Commute p
=> PatchChoices p wX wZ
-> (FL (LabelledPatch p) :> FL (LabelledPatch p)) wX wZ
separateFirstMiddleFromLast (PCs f l) =
case pushLasts l of
(m :> l') -> f +>+ m :> l'
-- | Retrieve the resulting sections from a 'PatchChoice'. The result is a
-- triple @first:>middle:>last@, such that all patches in @first@ are
-- 'InFirst', all patches in @middle@ are 'InMiddle', and all patches in @last@
-- are 'InLast'.
getChoices :: Commute p
=> PatchChoices p wX wY
-> (FL (LabelledPatch p) :> FL (LabelledPatch p) :> FL (LabelledPatch p)) wX wY
getChoices (PCs f ml) =
case pushLasts ml of
(m :> l') -> f :> m :> l'
-- | Internal function to commute patches in the common 'pcsMiddleLasts' segment
-- so that all 'InLast' patches are behind 'InMiddle' ones. Patches 'InMiddle'
-- that depend on any 'InLast' are promoted to 'InLast'.
pushLasts :: Commute p
=> FL (PatchChoice p) wX wY
-> (FL (LabelledPatch p) :> FL (LabelledPatch p)) wX wY
pushLasts NilFL = NilFL :> NilFL
pushLasts (PC lp False :>: pcs) =
case pushLasts pcs of
(m :> l) -> (lp :>: m) :> l
pushLasts (PC lp True :>: pcs) =
case pushLasts pcs of
(m :> l) ->
case commuteWhatWeCanFL (lp :> m) of
(m' :> lp' :> deps) -> m' :> (lp' :>: deps +>+ l)
-- TODO for the way we use this function it is too restrictive IMO: it does not
-- allow the user to select anything that doesn't match the pre-filters.
-- | Use the given monadic 'PatchChoices' transformer on the 'InMiddle' section
-- of a 'PatchChoices', then fold the result back into the original 'PatchChoices'.
refineChoices :: (Commute p, Monad m)
=> (forall wU wV . FL (LabelledPatch p) wU wV ->
PatchChoices p wU wV -> m (PatchChoices p wU wV))
-> PatchChoices p wX wY -> m (PatchChoices p wX wY)
refineChoices act ps =
case getChoices ps of
(f :> m :> l) -> do
(PCs f' l') <- act m (mkPatchChoices m)
return . PCs (f +>+ f') $ l' +>+ mapFL_FL (pcSetLast True) l
-- | Given a 'LabelledPatch' determine to which section of the given
-- 'PatchChoices' it belongs. This is not trivial to compute, since a patch
-- tagged as 'InMiddle' may be forced to actually be 'InLast' by dependencies. We
-- return a possibly re-ordered 'PatchChoices' so as not to waste the
-- commutation effort.
patchSlot :: forall p wA wB wX wY. Commute p
=> LabelledPatch p wA wB
-> PatchChoices p wX wY
-> (Slot, PatchChoices p wX wY)
patchSlot (LP t _) pc@(PCs f ml)
| foundIn f = (InFirst, pc)
| otherwise = psLast f NilRL NilRL ml
where
foundIn = anyFL ((== t) . label)
psLast :: forall wM wC wL .
FL (LabelledPatch p) wX wM ->
RL (LabelledPatch p) wM wC ->
RL (LabelledPatch p) wC wL ->
FL (PatchChoice p) wL wY ->
(Slot, PatchChoices p wX wY)
psLast firsts middles bubble (PC lp True :>: ls)
| label lp == t = (InLast
, PCs { pcsFirsts = firsts
, pcsMiddleLasts = settleM middles
+>+ settleB bubble
+>+ PC lp True :>: ls})
psLast firsts middles bubble (PC lp False :>: ls)
| label lp == t =
case commuteRL (bubble :> lp) of
Just (lp' :> bubble') -> (InMiddle,
PCs { pcsFirsts = firsts
, pcsMiddleLasts = settleM middles
+>+ PC lp' False
:>: settleB bubble'
+>+ ls})
Nothing -> (InLast,
PCs { pcsFirsts = firsts
, pcsMiddleLasts = settleM middles
+>+ settleB bubble
+>+ PC lp True
:>: ls})
psLast firsts middles bubble (PC lp True :>: ls) =
psLast firsts middles (bubble :<: lp) ls
psLast firsts middles bubble (PC lp False :>: ls) =
case commuteRL (bubble :> lp) of
Just (lp' :> bubble') -> psLast firsts (middles :<: lp') bubble' ls
Nothing -> psLast firsts middles (bubble :<: lp) ls
psLast _ _ _ NilFL = impossible
settleM middles = mapFL_FL (\lp -> PC lp False) $ reverseRL middles
settleB bubble = mapFL_FL (\lp -> PC lp True) $ reverseRL bubble
-- | Force all patches matching the given predicate to be 'InFirst',
-- pulling any dependencies with them. This even forces any patches
-- that were already tagged 'InLast'.
forceMatchingFirst :: forall p wA wB. Commute p
=> ( forall wX wY . LabelledPatch p wX wY -> Bool)
-> PatchChoices p wA wB
-> PatchChoices p wA wB
forceMatchingFirst pred (PCs f0 ml) = fmfLasts f0 NilRL ml
where
fmfLasts :: FL (LabelledPatch p) wA wM
-> RL (PatchChoice p) wM wN
-> FL (PatchChoice p) wN wB
-> PatchChoices p wA wB
fmfLasts f l1 (a :>: l2)
| pred_pc a =
case commuteWhatWeCanRL (l1 :> a) of
(deps :> a' :> l1') ->
let
f' = f +>+ mapFL_FL pcPatch (reverseRL deps) +>+ (pcPatch a' :>: NilFL)
in fmfLasts f' l1' l2
fmfLasts f l1 (a :>: l2) = fmfLasts f (l1 :<: a) l2
fmfLasts f l1 NilFL = PCs { pcsFirsts = f
, pcsMiddleLasts = reverseRL l1 }
pred_pc :: forall wX wY . PatchChoice p wX wY -> Bool
pred_pc (PC lp _) = pred lp
-- | Force all patches labelled with one of the given labels to be 'InFirst',
-- pulling any dependencies with them. This even forces any patches
-- that were already tagged 'InLast'.
forceFirsts :: Commute p
=> [Label] -> PatchChoices p wA wB -> PatchChoices p wA wB
forceFirsts ps = forceMatchingFirst ((`elem` ps) . label)
-- | Force a single patch labelled with the given label to be 'InFirst',
-- pulling any dependencies with them. This even forces any patches
-- that were already tagged 'InLast'.
forceFirst :: Commute p
=> Label -> PatchChoices p wA wB -> PatchChoices p wA wB
forceFirst p = forceMatchingFirst ((== p) . label)
--TODO: stop after having seen the patch we want to force first
-- | Make all 'InMiddle' patches either 'InFirst' or 'InLast'. This does *not*
-- modify any patches that are already determined to be 'InLast' by
-- dependencies.
selectAllMiddles :: forall p wX wY. Commute p
=> Bool -> PatchChoices p wX wY -> PatchChoices p wX wY
selectAllMiddles True (PCs f l) = PCs f (mapFL_FL g l)
where g (PC lp _) = PC lp True
selectAllMiddles False (PCs f l) = samf f NilRL NilRL l
where
samf :: forall wM1 wM2 wM3 .
FL (LabelledPatch p) wX wM1 ->
RL (LabelledPatch p) wM1 wM2 ->
RL (PatchChoice p) wM2 wM3 ->
FL (PatchChoice p) wM3 wY ->
PatchChoices p wX wY
samf f1 f2 l1 (pc@(PC lp False) :>: l2) =
case commuteRL (l1 :> pc) of
Nothing -> samf f1 f2 (l1 :<: PC lp True) l2
Just ((PC lp' _) :> l1') -> samf f1 (f2 :<: lp') l1' l2
samf f1 f2 l1 (PC lp True :>: l2) = samf f1 f2 (l1 :<: PC lp True) l2
samf f1 f2 l1 NilFL = PCs (f1 +>+ reverseRL f2) (reverseRL l1)
-- | Similar to 'forceMatchingFirst' only that patches are forced to be
-- 'InLast' regardless of their previous status.
forceMatchingLast :: Commute p => (forall wX wY . LabelledPatch p wX wY -> Bool)
-> PatchChoices p wA wB
-> PatchChoices p wA wB
forceMatchingLast pred (PCs f ml) =
forceMatchingMiddleOrLast pred True NilRL f ml
-- | Internal function working directly on the constituent parts of a
-- 'PatchChoices' and taking an accumulating 'RL' to build up a new 'InFirst'
-- section. It forces patches to be 'InMiddle' or 'InLast', depending
-- on the 'Bool' parameter ('True' means 'InLast', 'False' means 'InMiddle').
-- It does this regardless of the previous status of patches and also pulls
-- any dependent patches with it.
forceMatchingMiddleOrLast
:: forall p wA wB wM1 wM2 . Commute p
=> (forall wX wY . LabelledPatch p wX wY -> Bool)
-> Bool
-> RL (LabelledPatch p) wA wM1 -- ^ accumulator for 'InFirst' patches
-> FL (LabelledPatch p) wM1 wM2 -- ^ original 'InFirst' section
-> FL (PatchChoice p) wM2 wB -- ^ original 'InMiddle' and 'InLast' section
-> PatchChoices p wA wB
forceMatchingMiddleOrLast pred b f1 (a :>: f2) ml
| pred a =
case commuteWhatWeCanFL (a :> f2) of
(f2' :> a' :> deps) ->
let
ml' = mapFL_FL (pcSetLast b) (a' :>: deps) +>+ ml
in
forceMatchingMiddleOrLast pred b f1 f2' ml'
forceMatchingMiddleOrLast pred b f1 (a :>: f2) ml =
forceMatchingMiddleOrLast pred b (f1 :<: a) f2 ml
forceMatchingMiddleOrLast pred b f1 NilFL ml =
PCs { pcsFirsts = reverseRL f1
, pcsMiddleLasts = mapFL_FL choose ml
}
where
choose (PC lp c) = (PC lp (if pred lp then b else c) )
-- | Force all patches labelled with one of the given labels to be 'InLast',
-- pulling any dependencies with them. This even forces any patches
-- that were previously tagged 'InFirst'.
forceLasts :: Commute p
=> [Label] -> PatchChoices p wA wB -> PatchChoices p wA wB
forceLasts ps = forceMatchingLast ((`elem` ps) . label)
-- | Force a single patch labelled with the given label to be 'InLast',
-- pulling any dependencies with them, regardless of their previous status.
forceLast :: Commute p
=> Label -> PatchChoices p wA wB -> PatchChoices p wA wB
forceLast p = forceMatchingLast ((== p) . label)
-- | Force a patch with the given 'Label' to be 'InMiddle',
-- pulling any dependencies with it, regardless of their previous status.
forceMiddle :: Commute p => Label -> PatchChoices p wA wB -> PatchChoices p wA wB
forceMiddle t (PCs f l) = forceMatchingMiddleOrLast ((== t) . label) False NilRL f l
-- | Turn 'InFirst' patches into 'InMiddle' ones and 'InMiddle' into 'InLast' ones.
makeEverythingLater :: PatchChoices p wX wY -> PatchChoices p wX wY
makeEverythingLater (PCs f ml) =
let m = mapFL_FL (pcSetLast False) f
ml' = mapFL_FL (\(PC lp _) -> PC lp True) ml
in PCs NilFL $ m +>+ ml'
-- | Turn 'InMiddle' patches into 'InFirst' and 'InLast' patches into 'InMiddle'.
-- Does *not* pull dependencies into 'InFirst', instead patches that
-- cannot be commuted past 'InLast' patches stay 'InMiddle'.
makeEverythingSooner :: forall p wX wY. Commute p
=> PatchChoices p wX wY -> PatchChoices p wX wY
makeEverythingSooner (PCs f ml) =
case mes NilRL NilRL ml
of (m :> ml') ->
PCs (f +>+ m) ml'
where
mes :: forall wM1 wM2 wM3 .
RL (LabelledPatch p) wM1 wM2 ->
RL (LabelledPatch p) wM2 wM3 ->
FL (PatchChoice p) wM3 wY ->
(FL (LabelledPatch p) :> FL (PatchChoice p)) wM1 wY
mes middle bubble (PC lp True :>: mls) = mes middle (bubble :<: lp) mls
mes middle bubble (PC lp False :>: mls) =
case commuteRL (bubble :> lp) of
Nothing -> mes middle (bubble :<: lp) mls
Just (lp' :> bubble') -> mes (middle :<: lp') bubble' mls
mes middle bubble NilFL =
(reverseRL middle) :> mapFL_FL (\lp -> PC lp False) (reverseRL bubble)
-- | Substitute a single 'LabelledPatch' with an equivalent list of patches,
-- preserving its status as 'InFirst', 'InMiddle' or 'InLast').
-- The patch is looked up using equality of 'Label's.
substitute :: forall p wX wY .
Sealed2 (LabelledPatch p :||: FL (LabelledPatch p))
-> PatchChoices p wX wY
-> PatchChoices p wX wY
substitute (Sealed2 (lp :||: new_lps)) (PCs f l) =
PCs (concatFL $ mapFL_FL substLp f) (concatFL $ mapFL_FL substPc l)
where
substLp :: LabelledPatch p wA wB -> FL (LabelledPatch p) wA wB
substLp lp'
| IsEq <- compareLabels lp lp' = new_lps
| otherwise = lp' :>: NilFL
substPc :: PatchChoice p wA wB -> FL (PatchChoice p) wA wB
substPc (PC lp' c)
| IsEq <- compareLabels lp lp' = mapFL_FL (pcSetLast c) new_lps
| otherwise = PC lp' c :>: NilFL