{-| 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
    , matchOneOrRange
    , matchSeveralOrRange
    -- * exported for for checking
    , context
    , matchLast
    , matchFrom
    , matchAny -- temporary hack
    ) where

import Darcs.Prelude hiding ( last )

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 :: MatchOption
matchUpToOne = forall a. Monoid a => [a] -> a
mconcat [MatchOption
match, MatchOption
patch, MatchOption
hash, MatchOption
tag, MatchOption
index]

-- | Used by: clone
matchOneContext :: MatchOption
matchOneContext :: MatchOption
matchOneContext = forall a. Monoid a => [a] -> a
mconcat [MatchOption
toMatch, MatchOption
toPatch, MatchOption
toHash, MatchOption
tag, 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 :: MatchOption
matchOneNontag =  MatchOption
match forall a. Semigroup a => a -> a -> a
<> MatchOption
patch forall a. Semigroup a => a -> a -> a
<> MatchOption
hash

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

matchLast :: MatchOption
matchLast :: MatchOption
matchLast = MatchOption
last

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

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

-- | Used by: diff
matchOneOrRange :: MatchOption
matchOneOrRange :: MatchOption
matchOneOrRange = forall a. Monoid a => [a] -> a
mconcat [ MatchOption
match, MatchOption
patch, MatchOption
hash ] forall a. Semigroup a => a -> a -> a
<> MatchOption
matchRange

-- | Used by: show dependencies
matchRange :: MatchOption
matchRange :: MatchOption
matchRange = forall a. Monoid a => [a] -> a
mconcat [ MatchOption
matchTo, MatchOption
matchFrom, MatchOption
last, MatchOption
indexes ]

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

matchTo :: MatchOption
matchTo :: MatchOption
matchTo = MatchOption
toMatch forall a. Semigroup a => a -> a -> a
<> MatchOption
toPatch forall a. Semigroup a => a -> a -> a
<> MatchOption
toHash forall a. Semigroup a => a -> a -> a
<> MatchOption
toTag

matchFrom :: MatchOption
matchFrom :: MatchOption
matchFrom = MatchOption
fromMatch forall a. Semigroup a => a -> a -> a
<> MatchOption
fromPatch forall a. Semigroup a => a -> a -> a
<> MatchOption
fromHash forall a. Semigroup a => a -> a -> a
<> MatchOption
fromTag

matchAny :: MatchOption
matchAny :: MatchOption
matchAny = forall a. Monoid a => [a] -> a
mconcat [ MatchOption
toMatch, MatchOption
toPatch, MatchOption
toHash, MatchOption
toTag,
  MatchOption
fromMatch, MatchOption
fromPatch, MatchOption
fromHash, MatchOption
fromTag,
  MatchOption
tag, MatchOption
tags, MatchOption
patch, MatchOption
patches, MatchOption
hash, MatchOption
match, MatchOption
matches, MatchOption
index, MatchOption
indexes, MatchOption
context, 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 :: MatchOption
toMatch = OptSpec {[DarcsOptDescr Flag]
forall {t}. ([Flag] -> t) -> [MatchFlag] -> t
forall {t}. ([MatchFlag] -> t) -> [Flag] -> t
forall {p} {a}. p -> [a]
odesc :: [DarcsOptDescr Flag]
ocheck :: [Flag] -> [String]
oparse :: ([MatchFlag] -> a) -> [Flag] -> a
ounparse :: ([Flag] -> a) -> [MatchFlag] -> a
odesc :: [DarcsOptDescr Flag]
ocheck :: forall {p} {a}. p -> [a]
oparse :: forall {t}. ([MatchFlag] -> t) -> [Flag] -> t
ounparse :: forall {t}. ([Flag] -> t) -> [MatchFlag] -> t
..} where
  ounparse :: ([Flag] -> t) -> [MatchFlag] -> t
ounparse [Flag] -> t
k [MatchFlag]
mfs = [Flag] -> t
k [ String -> Flag
F.UpToPattern String
s | UpToPattern String
s <- [MatchFlag]
mfs ]
  oparse :: ([MatchFlag] -> t) -> [Flag] -> t
oparse [MatchFlag] -> t
k [Flag]
fs = [MatchFlag] -> t
k [ String -> MatchFlag
UpToPattern String
s | F.UpToPattern String
s <- [Flag]
fs ]
  ocheck :: p -> [a]
ocheck p
_ = []
  odesc :: [DarcsOptDescr Flag]
odesc = [ forall f. SingleArgOptDescr String f
strArg [] [String
"to-match"] String -> Flag
F.UpToPattern String
"PATTERN"
    String
"select changes up to a patch matching PATTERN" ]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

last :: MatchOption
last = OptSpec {[DarcsOptDescr Flag]
forall {t}. ([Flag] -> t) -> [MatchFlag] -> t
forall {t}. ([MatchFlag] -> t) -> [Flag] -> t
forall {p} {a}. p -> [a]
odesc :: [DarcsOptDescr Flag]
ocheck :: forall {p} {a}. p -> [a]
oparse :: forall {t}. ([MatchFlag] -> t) -> [Flag] -> t
ounparse :: forall {t}. ([Flag] -> t) -> [MatchFlag] -> t
odesc :: [DarcsOptDescr Flag]
ocheck :: [Flag] -> [String]
oparse :: ([MatchFlag] -> a) -> [Flag] -> a
ounparse :: ([Flag] -> a) -> [MatchFlag] -> a
..} where
  ounparse :: ([Flag] -> t) -> [MatchFlag] -> t
ounparse [Flag] -> t
k [MatchFlag]
mfs = [Flag] -> t
k [ String -> Flag
F.LastN (Int -> String
showIntArg Int
n) | LastN Int
n <- [MatchFlag]
mfs ]
  oparse :: ([MatchFlag] -> t) -> [Flag] -> t
oparse [MatchFlag] -> t
k [Flag]
fs = [MatchFlag] -> t
k [ Int -> MatchFlag
LastN (String -> Int
argparse String
s) | F.LastN String
s <- [Flag]
fs ]
  ocheck :: p -> [a]
ocheck p
_ = []
  odesc :: [DarcsOptDescr Flag]
odesc = [ forall f. SingleArgOptDescr String f
strArg [] [String
"last"] String -> Flag
F.LastN String
"NUMBER" String
"select the last NUMBER patches" ]
  argparse :: String -> Int
argparse = String -> (Int -> Bool) -> String -> Int
parseIntArg String
"count" (forall a. Ord a => a -> a -> Bool
>=Int
0)

index :: MatchOption
index = OptSpec {[DarcsOptDescr Flag]
forall {t}. ([Flag] -> t) -> [MatchFlag] -> t
forall {t}. ([MatchFlag] -> t) -> [Flag] -> t
forall {p} {a}. p -> [a]
odesc :: [DarcsOptDescr Flag]
ocheck :: forall {p} {a}. p -> [a]
oparse :: forall {t}. ([MatchFlag] -> t) -> [Flag] -> t
ounparse :: forall {t}. ([Flag] -> t) -> [MatchFlag] -> t
odesc :: [DarcsOptDescr Flag]
ocheck :: [Flag] -> [String]
oparse :: ([MatchFlag] -> a) -> [Flag] -> a
ounparse :: ([Flag] -> a) -> [MatchFlag] -> a
..} where
  ounparse :: ([Flag] -> t) -> [MatchFlag] -> t
ounparse [Flag] -> t
k [MatchFlag]
mfs = [Flag] -> t
k [ String -> Flag
F.OneIndex (Int -> String
showIntArg Int
n) | OneIndex Int
n <- [MatchFlag]
mfs ]
  oparse :: ([MatchFlag] -> t) -> [Flag] -> t
oparse [MatchFlag] -> t
k [Flag]
fs = [MatchFlag] -> t
k [ Int -> MatchFlag
OneIndex (String -> Int
argparse String
s) | F.OneIndex String
s <- [Flag]
fs ]
  ocheck :: p -> [a]
ocheck p
_ = []
  odesc :: [DarcsOptDescr Flag]
odesc = [ forall f. SingleArgOptDescr String f
strArg [Char
'n'] [String
"index"] String -> Flag
F.OneIndex String
"N" String
"select one patch" ]
  argparse :: String -> Int
argparse = String -> (Int -> Bool) -> String -> Int
parseIntArg String
"index" (forall a. Ord a => a -> a -> Bool
>Int
0)

indexes :: MatchOption
indexes = OptSpec {[DarcsOptDescr Flag]
forall {t}. ([Flag] -> t) -> [MatchFlag] -> t
forall {t}. ([MatchFlag] -> t) -> [Flag] -> t
forall {p} {a}. p -> [a]
odesc :: [DarcsOptDescr Flag]
ocheck :: forall {p} {a}. p -> [a]
oparse :: forall {t}. ([MatchFlag] -> t) -> [Flag] -> t
ounparse :: forall {t}. ([Flag] -> t) -> [MatchFlag] -> t
odesc :: [DarcsOptDescr Flag]
ocheck :: [Flag] -> [String]
oparse :: ([MatchFlag] -> a) -> [Flag] -> a
ounparse :: ([Flag] -> a) -> [MatchFlag] -> a
..} where
  ounparse :: ([Flag] -> t) -> [MatchFlag] -> t
ounparse [Flag] -> t
k [MatchFlag]
mfs = [Flag] -> t
k [ String -> Flag
F.IndexRange ((Int, Int) -> String
showIndexRangeArg (Int
n,Int
m)) | IndexRange Int
n Int
m <- [MatchFlag]
mfs ]
  oparse :: ([MatchFlag] -> t) -> [Flag] -> t
oparse [MatchFlag] -> t
k [Flag]
fs = [MatchFlag] -> t
k [ forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry Int -> Int -> MatchFlag
IndexRange (String -> (Int, Int)
argparse String
s) | F.IndexRange String
s <- [Flag]
fs ]
  ocheck :: p -> [a]
ocheck p
_ = []
  odesc :: [DarcsOptDescr Flag]
odesc = [ forall f. SingleArgOptDescr String f
strArg [Char
'n'] [String
"index"] String -> Flag
F.IndexRange String
"N-M" String
"select a range of patches" ]
  argparse :: String -> (Int, Int)
argparse = String -> (Int, Int)
parseIndexRangeArg