{-# LANGUAGE RecordWildCards #-}
{-| Patch matching options.

These are all of the same type 'MatchOption' defined below.

Multiple flags per option are allowed and do not raise a conflict error.
This is how Darcs currently operates, even though I suspect that it ignores
all but the first 'MatchFlag' (since it does so for many other options).

Given a suitable semantics (and documentation thereof), for instance \"all
the given patterns must match\", this could be turned into a useful feature.

-}
module Darcs.UI.Options.Matching
    ( MatchFlag(..) -- re-export
    , matchUpToOne
    , matchOneContext
    , matchOneNontag
    , matchSeveral
    , matchSeveralOrFirst
    , matchSeveralOrLast
    , matchRange
    , matchSeveralOrRange
    -- * exported for for checking
    , context
    , matchLast
    , matchFrom
    , matchAny -- temporary hack
    ) where

import Prelude ()
import Darcs.Prelude hiding ( last )

import Data.Char ( isDigit )

import Darcs.Patch.Match ( MatchFlag(..) )
import qualified Darcs.UI.Options.Flags as F ( DarcsFlag(..) )
import Darcs.UI.Options.Core
import Darcs.UI.Options.Util

-- * Type instantiations

type MatchOption = PrimDarcsOption [MatchFlag]

-- * Combined matching options

matchUpToOne :: MatchOption -- ^ show files/contents, dist, annotate
matchUpToOne :: PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
matchUpToOne = [PrimOptSpec DarcsOptDescr Flag a [MatchFlag]]
-> PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
forall a. Monoid a => [a] -> a
mconcat [PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
match, PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
patch, PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
hash, PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
tag, PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
index]

-- | Used by: clone
matchOneContext :: MatchOption
matchOneContext :: PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
matchOneContext = [PrimOptSpec DarcsOptDescr Flag a [MatchFlag]]
-> PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
forall a. Monoid a => [a] -> a
mconcat [PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
toMatch, PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
toPatch, PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
toHash, PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
tag, PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
context]

-- [NOTE --index removed from matchOneNontag because issue1926]
-- The --index option was removed for 2.5 release because it isn't handled
-- by amend-record (see issue1926).
--
-- At this moment, amend-record is the only command that uses 'matchOneNontag',
-- so there is no other command affected.

-- | Used by: amend
matchOneNontag :: MatchOption
matchOneNontag :: PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
matchOneNontag =  PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
match PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
-> PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
-> PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
forall a. Semigroup a => a -> a -> a
<> PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
patch PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
-> PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
-> PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
forall a. Semigroup a => a -> a -> a
<> PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
hash

-- | Used by: rebase pull/apply, send, push, pull, apply, fetch
matchSeveral :: MatchOption
matchSeveral :: PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
matchSeveral = PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
matches PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
-> PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
-> PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
forall a. Semigroup a => a -> a -> a
<> PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
patches PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
-> PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
-> PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
forall a. Semigroup a => a -> a -> a
<> PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
tags PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
-> PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
-> PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
forall a. Semigroup a => a -> a -> a
<> PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
hash

matchLast :: MatchOption
matchLast :: PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
matchLast = PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
last

-- | Used by: rebase unsuspend/reify
matchSeveralOrFirst :: MatchOption
matchSeveralOrFirst :: PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
matchSeveralOrFirst = [PrimOptSpec DarcsOptDescr Flag a [MatchFlag]]
-> PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
forall a. Monoid a => [a] -> a
mconcat [ PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
matchTo, PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
last, PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
matches, PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
patches, PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
tags, PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
hash ]

-- | Used by: unrecord, obliterate, rebase suspend, rollback
matchSeveralOrLast :: MatchOption
matchSeveralOrLast :: PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
matchSeveralOrLast = [PrimOptSpec DarcsOptDescr Flag a [MatchFlag]]
-> PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
forall a. Monoid a => [a] -> a
mconcat [ PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
matchFrom, PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
last, PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
matches, PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
patches, PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
tags, PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
hash ]

-- | Used by: diff
matchRange :: MatchOption
matchRange :: PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
matchRange = [PrimOptSpec DarcsOptDescr Flag a [MatchFlag]]
-> PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
forall a. Monoid a => [a] -> a
mconcat [ PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
matchTo, PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
matchFrom, PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
match, PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
patch, PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
hash, PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
last, PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
indexes ]

-- | Used by: log
matchSeveralOrRange :: MatchOption
matchSeveralOrRange :: PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
matchSeveralOrRange = [PrimOptSpec DarcsOptDescr Flag a [MatchFlag]]
-> PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
forall a. Monoid a => [a] -> a
mconcat
  [ PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
matchTo, PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
matchFrom, PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
last, PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
indexes, PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
matches, PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
patches, PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
tags, PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
hash ]

matchTo :: MatchOption
matchTo :: PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
matchTo = PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
toMatch PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
-> PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
-> PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
forall a. Semigroup a => a -> a -> a
<> PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
toPatch PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
-> PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
-> PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
forall a. Semigroup a => a -> a -> a
<> PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
toHash PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
-> PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
-> PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
forall a. Semigroup a => a -> a -> a
<> PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
toTag

matchFrom :: MatchOption
matchFrom :: PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
matchFrom = PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
fromMatch PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
-> PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
-> PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
forall a. Semigroup a => a -> a -> a
<> PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
fromPatch PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
-> PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
-> PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
forall a. Semigroup a => a -> a -> a
<> PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
fromHash PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
-> PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
-> PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
forall a. Semigroup a => a -> a -> a
<> PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
fromTag

matchAny :: MatchOption
matchAny :: PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
matchAny = [PrimOptSpec DarcsOptDescr Flag a [MatchFlag]]
-> PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
forall a. Monoid a => [a] -> a
mconcat [ PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
toMatch, PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
toPatch, PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
toHash, PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
toTag,
  PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
fromMatch, PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
fromPatch, PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
fromHash, PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
fromTag,
  PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
tag, PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
tags, PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
patch, PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
patches, PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
hash, PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
match, PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
matches, PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
index, PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
indexes, PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
context, PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
last ]

-- * Primitive matching options

toMatch, toPatch, toHash, toTag,
  fromMatch, fromPatch, fromHash, fromTag,
  tag, tags,
  patch, patches,
  hash,
  match, matches,
  index, indexes,
  context, last :: MatchOption

toMatch :: PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
toMatch = OptSpec :: forall (d :: * -> *) f a b.
(([f] -> a) -> b)
-> (b -> [f] -> a) -> ([f] -> [String]) -> [d f] -> OptSpec d f a b
OptSpec {..} where
  ounparse :: ([Flag] -> t) -> [MatchFlag] -> t
ounparse k :: [Flag] -> t
k mfs :: [MatchFlag]
mfs = [Flag] -> t
k [ String -> Flag
F.UpToPattern String
s | UpToPattern s :: String
s <- [MatchFlag]
mfs ]
  oparse :: ([MatchFlag] -> t) -> [Flag] -> t
oparse k :: [MatchFlag] -> t
k fs :: [Flag]
fs = [MatchFlag] -> t
k [ String -> MatchFlag
UpToPattern String
s | F.UpToPattern s :: String
s <- [Flag]
fs ]
  ocheck :: p -> [a]
ocheck _ = []
  odesc :: [DarcsOptDescr Flag]
odesc = [ SingleArgOptDescr String Flag
forall f. SingleArgOptDescr String f
strArg [] ["to-match"] String -> Flag
F.UpToPattern "PATTERN"
    "select changes up to a patch matching PATTERN" ]

toPatch :: PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
toPatch = OptSpec :: forall (d :: * -> *) f a b.
(([f] -> a) -> b)
-> (b -> [f] -> a) -> ([f] -> [String]) -> [d f] -> OptSpec d f a b
OptSpec {..} where
  ounparse :: ([Flag] -> t) -> [MatchFlag] -> t
ounparse k :: [Flag] -> t
k mfs :: [MatchFlag]
mfs = [Flag] -> t
k [ String -> Flag
F.UpToPatch String
s | UpToPatch s :: String
s <- [MatchFlag]
mfs ]
  oparse :: ([MatchFlag] -> t) -> [Flag] -> t
oparse k :: [MatchFlag] -> t
k fs :: [Flag]
fs = [MatchFlag] -> t
k [ String -> MatchFlag
UpToPatch String
s | F.UpToPatch s :: String
s <- [Flag]
fs ]
  ocheck :: p -> [a]
ocheck _ = []
  odesc :: [DarcsOptDescr Flag]
odesc = [ SingleArgOptDescr String Flag
forall f. SingleArgOptDescr String f
strArg [] ["to-patch"] String -> Flag
F.UpToPatch "REGEXP"
    "select changes up to a patch matching REGEXP" ]

toHash :: PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
toHash = OptSpec :: forall (d :: * -> *) f a b.
(([f] -> a) -> b)
-> (b -> [f] -> a) -> ([f] -> [String]) -> [d f] -> OptSpec d f a b
OptSpec {..} where
  ounparse :: ([Flag] -> t) -> [MatchFlag] -> t
ounparse k :: [Flag] -> t
k mfs :: [MatchFlag]
mfs = [Flag] -> t
k [ String -> Flag
F.UpToHash String
s | UpToHash s :: String
s <- [MatchFlag]
mfs ]
  oparse :: ([MatchFlag] -> t) -> [Flag] -> t
oparse k :: [MatchFlag] -> t
k fs :: [Flag]
fs = [MatchFlag] -> t
k [ String -> MatchFlag
UpToHash String
s | F.UpToHash s :: String
s <- [Flag]
fs ]
  ocheck :: p -> [a]
ocheck _ = []
  odesc :: [DarcsOptDescr Flag]
odesc = [ SingleArgOptDescr String Flag
forall f. SingleArgOptDescr String f
strArg [] ["to-hash"] String -> Flag
F.UpToHash "HASH"
    "select changes up to a patch with HASH" ]

context :: PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
context = OptSpec :: forall (d :: * -> *) f a b.
(([f] -> a) -> b)
-> (b -> [f] -> a) -> ([f] -> [String]) -> [d f] -> OptSpec d f a b
OptSpec {..} where
  ounparse :: ([Flag] -> t) -> [MatchFlag] -> t
ounparse k :: [Flag] -> t
k mfs :: [MatchFlag]
mfs = [Flag] -> t
k [ AbsolutePath -> Flag
F.Context AbsolutePath
p | Context p :: AbsolutePath
p <- [MatchFlag]
mfs ]
  oparse :: ([MatchFlag] -> t) -> [Flag] -> t
oparse k :: [MatchFlag] -> t
k fs :: [Flag]
fs = [MatchFlag] -> t
k [ AbsolutePath -> MatchFlag
Context AbsolutePath
p | F.Context p :: AbsolutePath
p <- [Flag]
fs ]
  ocheck :: p -> [a]
ocheck _ = []
  odesc :: [DarcsOptDescr Flag]
odesc = [ SingleArgOptDescr AbsolutePath Flag
forall f. SingleArgOptDescr AbsolutePath f
absPathArg [] ["context"] AbsolutePath -> Flag
F.Context "FILENAME"
    "version specified by the context in FILENAME" ]

toTag :: PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
toTag = OptSpec :: forall (d :: * -> *) f a b.
(([f] -> a) -> b)
-> (b -> [f] -> a) -> ([f] -> [String]) -> [d f] -> OptSpec d f a b
OptSpec {..} where
  ounparse :: ([Flag] -> t) -> [MatchFlag] -> t
ounparse k :: [Flag] -> t
k mfs :: [MatchFlag]
mfs = [Flag] -> t
k [ String -> Flag
F.UpToTag String
s | UpToTag s :: String
s <- [MatchFlag]
mfs ]
  oparse :: ([MatchFlag] -> t) -> [Flag] -> t
oparse k :: [MatchFlag] -> t
k fs :: [Flag]
fs = [MatchFlag] -> t
k [ String -> MatchFlag
UpToTag String
s | F.UpToTag s :: String
s <- [Flag]
fs ]
  ocheck :: p -> [a]
ocheck _ = []
  odesc :: [DarcsOptDescr Flag]
odesc = [ SingleArgOptDescr String Flag
forall f. SingleArgOptDescr String f
strArg [] ["to-tag"] String -> Flag
F.UpToTag "REGEXP"
    "select changes up to a tag matching REGEXP" ]

fromMatch :: PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
fromMatch = OptSpec :: forall (d :: * -> *) f a b.
(([f] -> a) -> b)
-> (b -> [f] -> a) -> ([f] -> [String]) -> [d f] -> OptSpec d f a b
OptSpec {..} where
  ounparse :: ([Flag] -> t) -> [MatchFlag] -> t
ounparse k :: [Flag] -> t
k mfs :: [MatchFlag]
mfs = [Flag] -> t
k [ String -> Flag
F.AfterPattern String
s | AfterPattern s :: String
s <- [MatchFlag]
mfs ]
  oparse :: ([MatchFlag] -> t) -> [Flag] -> t
oparse k :: [MatchFlag] -> t
k fs :: [Flag]
fs = [MatchFlag] -> t
k [ String -> MatchFlag
AfterPattern String
s | F.AfterPattern s :: String
s <- [Flag]
fs ]
  ocheck :: p -> [a]
ocheck _ = []
  odesc :: [DarcsOptDescr Flag]
odesc = [ SingleArgOptDescr String Flag
forall f. SingleArgOptDescr String f
strArg [] ["from-match"] String -> Flag
F.AfterPattern "PATTERN"
    "select changes starting with a patch matching PATTERN" ]

fromPatch :: PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
fromPatch = OptSpec :: forall (d :: * -> *) f a b.
(([f] -> a) -> b)
-> (b -> [f] -> a) -> ([f] -> [String]) -> [d f] -> OptSpec d f a b
OptSpec {..} where
  ounparse :: ([Flag] -> t) -> [MatchFlag] -> t
ounparse k :: [Flag] -> t
k mfs :: [MatchFlag]
mfs = [Flag] -> t
k [ String -> Flag
F.AfterPatch String
s | AfterPatch s :: String
s <- [MatchFlag]
mfs ]
  oparse :: ([MatchFlag] -> t) -> [Flag] -> t
oparse k :: [MatchFlag] -> t
k fs :: [Flag]
fs = [MatchFlag] -> t
k [ String -> MatchFlag
AfterPatch String
s | F.AfterPatch s :: String
s <- [Flag]
fs ]
  ocheck :: p -> [a]
ocheck _ = []
  odesc :: [DarcsOptDescr Flag]
odesc = [ SingleArgOptDescr String Flag
forall f. SingleArgOptDescr String f
strArg [] ["from-patch"] String -> Flag
F.AfterPatch "REGEXP"
    "select changes starting with a patch matching REGEXP" ]

fromHash :: PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
fromHash = OptSpec :: forall (d :: * -> *) f a b.
(([f] -> a) -> b)
-> (b -> [f] -> a) -> ([f] -> [String]) -> [d f] -> OptSpec d f a b
OptSpec {..} where
  ounparse :: ([Flag] -> t) -> [MatchFlag] -> t
ounparse k :: [Flag] -> t
k mfs :: [MatchFlag]
mfs = [Flag] -> t
k [ String -> Flag
F.AfterHash String
s | AfterHash s :: String
s <- [MatchFlag]
mfs ]
  oparse :: ([MatchFlag] -> t) -> [Flag] -> t
oparse k :: [MatchFlag] -> t
k fs :: [Flag]
fs = [MatchFlag] -> t
k [ String -> MatchFlag
AfterHash String
s | F.AfterHash s :: String
s <- [Flag]
fs ]
  ocheck :: p -> [a]
ocheck _ = []
  odesc :: [DarcsOptDescr Flag]
odesc = [ SingleArgOptDescr String Flag
forall f. SingleArgOptDescr String f
strArg [] ["from-hash"] String -> Flag
F.AfterHash "HASH"
    "select changes starting with a patch with HASH" ]

fromTag :: PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
fromTag = OptSpec :: forall (d :: * -> *) f a b.
(([f] -> a) -> b)
-> (b -> [f] -> a) -> ([f] -> [String]) -> [d f] -> OptSpec d f a b
OptSpec {..} where
  ounparse :: ([Flag] -> t) -> [MatchFlag] -> t
ounparse k :: [Flag] -> t
k mfs :: [MatchFlag]
mfs = [Flag] -> t
k [ String -> Flag
F.AfterTag String
s | AfterTag s :: String
s <- [MatchFlag]
mfs ]
  oparse :: ([MatchFlag] -> t) -> [Flag] -> t
oparse k :: [MatchFlag] -> t
k fs :: [Flag]
fs = [MatchFlag] -> t
k [ String -> MatchFlag
AfterTag String
s | F.AfterTag s :: String
s <- [Flag]
fs ]
  ocheck :: p -> [a]
ocheck _ = []
  odesc :: [DarcsOptDescr Flag]
odesc = [ SingleArgOptDescr String Flag
forall f. SingleArgOptDescr String f
strArg [] ["from-tag"] String -> Flag
F.AfterTag "REGEXP"
    "select changes starting with a tag matching REGEXP" ]

tag :: PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
tag = OptSpec :: forall (d :: * -> *) f a b.
(([f] -> a) -> b)
-> (b -> [f] -> a) -> ([f] -> [String]) -> [d f] -> OptSpec d f a b
OptSpec {..} where
  ounparse :: ([Flag] -> t) -> [MatchFlag] -> t
ounparse k :: [Flag] -> t
k mfs :: [MatchFlag]
mfs = [Flag] -> t
k [ String -> Flag
F.OneTag String
s | OneTag s :: String
s <- [MatchFlag]
mfs ]
  oparse :: ([MatchFlag] -> t) -> [Flag] -> t
oparse k :: [MatchFlag] -> t
k fs :: [Flag]
fs = [MatchFlag] -> t
k [ String -> MatchFlag
OneTag String
s | F.OneTag s :: String
s <- [Flag]
fs ]
  ocheck :: p -> [a]
ocheck _ = []
  odesc :: [DarcsOptDescr Flag]
odesc = [ SingleArgOptDescr String Flag
forall f. SingleArgOptDescr String f
strArg ['t'] ["tag"] String -> Flag
F.OneTag "REGEXP" "select tag matching REGEXP" ]

tags :: PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
tags = OptSpec :: forall (d :: * -> *) f a b.
(([f] -> a) -> b)
-> (b -> [f] -> a) -> ([f] -> [String]) -> [d f] -> OptSpec d f a b
OptSpec {..} where
  ounparse :: ([Flag] -> t) -> [MatchFlag] -> t
ounparse k :: [Flag] -> t
k mfs :: [MatchFlag]
mfs = [Flag] -> t
k [ String -> Flag
F.OneTag String
s | OneTag s :: String
s <- [MatchFlag]
mfs ]
  oparse :: ([MatchFlag] -> t) -> [Flag] -> t
oparse k :: [MatchFlag] -> t
k fs :: [Flag]
fs = [MatchFlag] -> t
k [ String -> MatchFlag
OneTag String
s | F.OneTag s :: String
s <- [Flag]
fs ]
  ocheck :: p -> [a]
ocheck _ = []
  odesc :: [DarcsOptDescr Flag]
odesc = [ SingleArgOptDescr String Flag
forall f. SingleArgOptDescr String f
strArg ['t'] ["tags"] String -> Flag
F.OneTag "REGEXP" "select tags matching REGEXP" ]

patch :: PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
patch = OptSpec :: forall (d :: * -> *) f a b.
(([f] -> a) -> b)
-> (b -> [f] -> a) -> ([f] -> [String]) -> [d f] -> OptSpec d f a b
OptSpec {..} where
  ounparse :: ([Flag] -> t) -> [MatchFlag] -> t
ounparse k :: [Flag] -> t
k mfs :: [MatchFlag]
mfs = [Flag] -> t
k [ String -> Flag
F.OnePatch String
s | OnePatch s :: String
s <- [MatchFlag]
mfs ]
  oparse :: ([MatchFlag] -> t) -> [Flag] -> t
oparse k :: [MatchFlag] -> t
k fs :: [Flag]
fs = [MatchFlag] -> t
k [ String -> MatchFlag
OnePatch String
s | F.OnePatch s :: String
s <- [Flag]
fs ]
  ocheck :: p -> [a]
ocheck _ = []
  odesc :: [DarcsOptDescr Flag]
odesc = [ SingleArgOptDescr String Flag
forall f. SingleArgOptDescr String f
strArg ['p'] ["patch"] String -> Flag
F.OnePatch "REGEXP"
    "select a single patch matching REGEXP" ]

patches :: PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
patches = OptSpec :: forall (d :: * -> *) f a b.
(([f] -> a) -> b)
-> (b -> [f] -> a) -> ([f] -> [String]) -> [d f] -> OptSpec d f a b
OptSpec {..} where
  ounparse :: ([Flag] -> t) -> [MatchFlag] -> t
ounparse k :: [Flag] -> t
k mfs :: [MatchFlag]
mfs = [Flag] -> t
k [ String -> Flag
F.SeveralPatch String
s | SeveralPatch s :: String
s <- [MatchFlag]
mfs ]
  oparse :: ([MatchFlag] -> t) -> [Flag] -> t
oparse k :: [MatchFlag] -> t
k fs :: [Flag]
fs = [MatchFlag] -> t
k [ String -> MatchFlag
SeveralPatch String
s | F.SeveralPatch s :: String
s <- [Flag]
fs ]
  ocheck :: p -> [a]
ocheck _ = []
  odesc :: [DarcsOptDescr Flag]
odesc = [ SingleArgOptDescr String Flag
forall f. SingleArgOptDescr String f
strArg ['p'] ["patches"] String -> Flag
F.SeveralPatch "REGEXP"
    "select patches matching REGEXP" ]

hash :: PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
hash = OptSpec :: forall (d :: * -> *) f a b.
(([f] -> a) -> b)
-> (b -> [f] -> a) -> ([f] -> [String]) -> [d f] -> OptSpec d f a b
OptSpec {..} where
  ounparse :: ([Flag] -> t) -> [MatchFlag] -> t
ounparse k :: [Flag] -> t
k mfs :: [MatchFlag]
mfs = [Flag] -> t
k [ String -> Flag
F.OneHash String
s | OneHash s :: String
s <- [MatchFlag]
mfs ]
  oparse :: ([MatchFlag] -> t) -> [Flag] -> t
oparse k :: [MatchFlag] -> t
k fs :: [Flag]
fs = [MatchFlag] -> t
k [ String -> MatchFlag
OneHash String
s | F.OneHash s :: String
s <- [Flag]
fs ]
  ocheck :: p -> [a]
ocheck _ = []
  odesc :: [DarcsOptDescr Flag]
odesc = [ SingleArgOptDescr String Flag
forall f. SingleArgOptDescr String f
strArg ['h'] ["hash"] String -> Flag
F.OneHash "HASH"
    "select a single patch with HASH" ]

match :: PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
match = OptSpec :: forall (d :: * -> *) f a b.
(([f] -> a) -> b)
-> (b -> [f] -> a) -> ([f] -> [String]) -> [d f] -> OptSpec d f a b
OptSpec {..} where
  ounparse :: ([Flag] -> t) -> [MatchFlag] -> t
ounparse k :: [Flag] -> t
k mfs :: [MatchFlag]
mfs = [Flag] -> t
k [ String -> Flag
F.OnePattern String
s | OnePattern s :: String
s <- [MatchFlag]
mfs ]
  oparse :: ([MatchFlag] -> t) -> [Flag] -> t
oparse k :: [MatchFlag] -> t
k fs :: [Flag]
fs = [MatchFlag] -> t
k [ String -> MatchFlag
OnePattern String
s | F.OnePattern s :: String
s <- [Flag]
fs ]
  ocheck :: p -> [a]
ocheck _ = []
  odesc :: [DarcsOptDescr Flag]
odesc = [ SingleArgOptDescr String Flag
forall f. SingleArgOptDescr String f
strArg [] ["match"] String -> Flag
F.OnePattern "PATTERN"
    "select a single patch matching PATTERN" ]

matches :: PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
matches = OptSpec :: forall (d :: * -> *) f a b.
(([f] -> a) -> b)
-> (b -> [f] -> a) -> ([f] -> [String]) -> [d f] -> OptSpec d f a b
OptSpec {..} where
  ounparse :: ([Flag] -> t) -> [MatchFlag] -> t
ounparse k :: [Flag] -> t
k mfs :: [MatchFlag]
mfs = [Flag] -> t
k [ String -> Flag
F.SeveralPattern String
s | SeveralPattern s :: String
s <- [MatchFlag]
mfs ]
  oparse :: ([MatchFlag] -> t) -> [Flag] -> t
oparse k :: [MatchFlag] -> t
k fs :: [Flag]
fs = [MatchFlag] -> t
k [ String -> MatchFlag
SeveralPattern String
s | F.SeveralPattern s :: String
s <- [Flag]
fs ]
  ocheck :: p -> [a]
ocheck _ = []
  odesc :: [DarcsOptDescr Flag]
odesc = [ SingleArgOptDescr String Flag
forall f. SingleArgOptDescr String f
strArg [] ["matches"] String -> Flag
F.SeveralPattern "PATTERN"
    "select patches matching PATTERN" ]

last :: PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
last = OptSpec :: forall (d :: * -> *) f a b.
(([f] -> a) -> b)
-> (b -> [f] -> a) -> ([f] -> [String]) -> [d f] -> OptSpec d f a b
OptSpec {..} where
  ounparse :: ([Flag] -> t) -> [MatchFlag] -> t
ounparse k :: [Flag] -> t
k mfs :: [MatchFlag]
mfs = [Flag] -> t
k [ Int -> Flag
F.LastN Int
s | LastN s :: Int
s <- [MatchFlag]
mfs ]
  oparse :: ([MatchFlag] -> t) -> [Flag] -> t
oparse k :: [MatchFlag] -> t
k fs :: [Flag]
fs = [MatchFlag] -> t
k [ Int -> MatchFlag
LastN Int
s | F.LastN s :: Int
s <- [Flag]
fs ]
  ocheck :: p -> [a]
ocheck _ = []
  odesc :: [DarcsOptDescr Flag]
odesc = [ SingleArgOptDescr String Flag
forall f. SingleArgOptDescr String f
strArg [] ["last"] (Int -> Flag
F.LastN (Int -> Flag) -> (String -> Int) -> String -> Flag
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Int
forall p. (Read p, Num p) => String -> p
toInt) "NUMBER"
    "select the last NUMBER patches" ]
  toInt :: String -> p
toInt s :: String
s = if Bool -> Bool
not (String -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null String
s) Bool -> Bool -> Bool
&& (Char -> Bool) -> String -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
all Char -> Bool
isDigit String
s then String -> p
forall a. Read a => String -> a
read String
s else (-1)

-- | TODO: see 'Darcs.UI.Options.maxCount'.
index :: PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
index = OptSpec :: forall (d :: * -> *) f a b.
(([f] -> a) -> b)
-> (b -> [f] -> a) -> ([f] -> [String]) -> [d f] -> OptSpec d f a b
OptSpec {..} where
  ounparse :: ([Flag] -> t) -> [MatchFlag] -> t
ounparse k :: [Flag] -> t
k mfs :: [MatchFlag]
mfs = [Flag] -> t
k [ Int -> Int -> Flag
F.PatchIndexRange Int
n Int
m | PatchIndexRange n :: Int
n m :: Int
m <- [MatchFlag]
mfs ]
  oparse :: ([MatchFlag] -> t) -> [Flag] -> t
oparse k :: [MatchFlag] -> t
k fs :: [Flag]
fs = [MatchFlag] -> t
k [ Int -> Int -> MatchFlag
PatchIndexRange Int
n Int
m | F.PatchIndexRange n :: Int
n m :: Int
m <- [Flag]
fs ]
  ocheck :: p -> [a]
ocheck _ = []
  odesc :: [DarcsOptDescr Flag]
odesc = [ SingleArgOptDescr String Flag
forall f. SingleArgOptDescr String f
strArg ['n'] ["index"] String -> Flag
indexrange "N" "select one patch" ]
  indexrange :: String -> Flag
indexrange s :: String
s = if (Char -> Bool) -> String -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
all Char -> Bool
isDigit String
s
                 then Int -> Int -> Flag
F.PatchIndexRange (String -> Int
forall a. Read a => String -> a
read String
s) (String -> Int
forall a. Read a => String -> a
read String
s)
                 else Int -> Int -> Flag
F.PatchIndexRange 0 0

-- | TODO: see 'Darcs.UI.Options.maxCount'.
indexes :: PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
indexes = OptSpec :: forall (d :: * -> *) f a b.
(([f] -> a) -> b)
-> (b -> [f] -> a) -> ([f] -> [String]) -> [d f] -> OptSpec d f a b
OptSpec {..} where
  ounparse :: ([Flag] -> t) -> [MatchFlag] -> t
ounparse k :: [Flag] -> t
k mfs :: [MatchFlag]
mfs = [Flag] -> t
k [ Int -> Int -> Flag
F.PatchIndexRange Int
n Int
m | PatchIndexRange n :: Int
n m :: Int
m <- [MatchFlag]
mfs ]
  oparse :: ([MatchFlag] -> t) -> [Flag] -> t
oparse k :: [MatchFlag] -> t
k fs :: [Flag]
fs = [MatchFlag] -> t
k [ Int -> Int -> MatchFlag
PatchIndexRange Int
n Int
m | F.PatchIndexRange n :: Int
n m :: Int
m <- [Flag]
fs ]
  ocheck :: p -> [a]
ocheck _ = []
  odesc :: [DarcsOptDescr Flag]
odesc = [ SingleArgOptDescr String Flag
forall f. SingleArgOptDescr String f
strArg ['n'] ["index"] String -> Flag
indexrange "N-M" "select a range of patches" ]
  indexrange :: String -> Flag
indexrange s :: String
s = if (Char -> Bool) -> String -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
all Char -> Bool
isokay String
s
                 then if '-' Char -> String -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` String
s
                      then let x1 :: String
x1 = (Char -> Bool) -> String -> String
forall a. (a -> Bool) -> [a] -> [a]
takeWhile (Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
/= '-') String
s
                               x2 :: String
x2 = String -> String
forall a. [a] -> [a]
reverse (String -> String) -> String -> String
forall a b. (a -> b) -> a -> b
$ (Char -> Bool) -> String -> String
forall a. (a -> Bool) -> [a] -> [a]
takeWhile (Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
/= '-') (String -> String) -> String -> String
forall a b. (a -> b) -> a -> b
$ String -> String
forall a. [a] -> [a]
reverse String
s
                           in Int -> Int -> Flag
F.PatchIndexRange (String -> Int
forall a. Read a => String -> a
read String
x1) (String -> Int
forall a. Read a => String -> a
read String
x2)
                      else Int -> Int -> Flag
F.PatchIndexRange (String -> Int
forall a. Read a => String -> a
read String
s) (String -> Int
forall a. Read a => String -> a
read String
s)
                 else Int -> Int -> Flag
F.PatchIndexRange 0 0
  isokay :: Char -> Bool
isokay c :: Char
c = Char -> Bool
isDigit Char
c Bool -> Bool -> Bool
|| Char
c Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== '-'