{-# LANGUAGE NamedFieldPuns #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE TemplateHaskell #-}

-- |
-- Module      : Git.Stale.Parsing
-- License     : BSD3
-- Maintainer  : tbidne@gmail.com
-- Handles parsing of String args into 'Env'.
module Git.Stale.Parsing
  ( parseArgs,
  )
where

import Common.Parsing.Core
import Common.RefinedUtils
import Common.Utils
import Control.Applicative ((<|>))
import qualified Data.Text as T
import qualified Data.Time.Calendar as Cal
import Git.Stale.Types.Env
import qualified System.IO as IO
import qualified Text.Read as TR

-- | Maps `Cal.Day` and parsed [`String`] args into `Right` `Env`, returning
-- any errors as `Left` `ParseErr`. All arguments are optional
-- (i.e. an empty list is valid), but if any are provided then they must
-- be valid or an error will be returned. Valid arguments are:
--
-- @
--   --grep=\<string\>
--       Used for filtering on branch names. Any `String` is fine,
--       defaults to the empty string.
--
--   --path=\<string>\
--       Path to the git directory. Any `String` is fine, defaults
--       to the empty string (current directory).
--
--   --limit=\<days\>
--       Determines if a branch should be considered stale. Must be a
--       non-negative integer. Defaults to 30.
--
--   -a, --branch-type=all
--       Searches local and remote branches.
--
--   -r, --branch-type=remote
--       Searches remote branches only. This is the default.
--
--   -l, --branch-type=local
--       Searches local branches only.
--
--   --remote=\<string\>
--       Name of the remote, used for stripping out the the remote name for
--       display purposes. Any `String` is fine, including the empty string.
--       Defaults to origin/.
--
--   --master=\<string\>
--       Name of the branch to consider merges against. Any `String` is fine,
--       including the empty string. Defaults to origin/master.
--
--  -h, --help
--       Returns instructions as `Left` `String`.
-- @
parseArgs :: Cal.Day -> [String] -> Either ParseErr Env
parseArgs :: Day -> [String] -> Either ParseErr Env
parseArgs d :: Day
d args :: [String]
args =
  case [AnyParser Acc] -> [String] -> ParseAnd Acc
forall acc.
Monoid acc =>
[AnyParser acc] -> [String] -> ParseAnd acc
parseAll [AnyParser Acc]
allParsers [String]
args of
    ParseAnd (PFailure (Help _)) -> ParseErr -> Either ParseErr Env
forall a b. a -> Either a b
Left (ParseErr -> Either ParseErr Env)
-> ParseErr -> Either ParseErr Env
forall a b. (a -> b) -> a -> b
$ String -> ParseErr
Help String
help
    ParseAnd (PFailure (Err arg :: String
arg)) ->
      ParseErr -> Either ParseErr Env
forall a b. a -> Either a b
Left (ParseErr -> Either ParseErr Env)
-> ParseErr -> Either ParseErr Env
forall a b. (a -> b) -> a -> b
$ String -> ParseErr
Err (String -> ParseErr) -> String -> ParseErr
forall a b. (a -> b) -> a -> b
$ "Could not parse `" String -> String -> String
forall a. Semigroup a => a -> a -> a
<> String
arg String -> String -> String
forall a. Semigroup a => a -> a -> a
<> "`. Try --help."
    ParseAnd (PSuccess acc :: Acc
acc) -> Env -> Either ParseErr Env
forall a b. b -> Either a b
Right (Env -> Either ParseErr Env) -> Env -> Either ParseErr Env
forall a b. (a -> b) -> a -> b
$ Day -> Acc -> Env
accToEnv Day
d Acc
acc

newtype AccLimit = AccLimit (RNonNegative Int) deriving (Int -> AccLimit -> String -> String
[AccLimit] -> String -> String
AccLimit -> String
(Int -> AccLimit -> String -> String)
-> (AccLimit -> String)
-> ([AccLimit] -> String -> String)
-> Show AccLimit
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [AccLimit] -> String -> String
$cshowList :: [AccLimit] -> String -> String
show :: AccLimit -> String
$cshow :: AccLimit -> String
showsPrec :: Int -> AccLimit -> String -> String
$cshowsPrec :: Int -> AccLimit -> String -> String
Show)

instance Semigroup AccLimit where
  (AccLimit l :: RNonNegative Int
l) <> :: AccLimit -> AccLimit -> AccLimit
<> r :: AccLimit
r
    | (RNonNegative Int -> Int
forall p x. Refined p x -> x
unrefine RNonNegative Int
l Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== 30) = AccLimit
r
    | Bool
otherwise = (RNonNegative Int -> AccLimit
AccLimit RNonNegative Int
l)

instance Monoid AccLimit where
  mempty :: AccLimit
mempty = RNonNegative Int -> AccLimit
AccLimit (RNonNegative Int -> AccLimit) -> RNonNegative Int -> AccLimit
forall a b. (a -> b) -> a -> b
$ $$(refineTH 30)

newtype AccBranchType = AccBranchType BranchType deriving (Int -> AccBranchType -> String -> String
[AccBranchType] -> String -> String
AccBranchType -> String
(Int -> AccBranchType -> String -> String)
-> (AccBranchType -> String)
-> ([AccBranchType] -> String -> String)
-> Show AccBranchType
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [AccBranchType] -> String -> String
$cshowList :: [AccBranchType] -> String -> String
show :: AccBranchType -> String
$cshow :: AccBranchType -> String
showsPrec :: Int -> AccBranchType -> String -> String
$cshowsPrec :: Int -> AccBranchType -> String -> String
Show)

instance Semigroup AccBranchType where
  (AccBranchType Remote) <> :: AccBranchType -> AccBranchType -> AccBranchType
<> r :: AccBranchType
r = AccBranchType
r
  l :: AccBranchType
l <> _ = AccBranchType
l

instance Monoid AccBranchType where
  mempty :: AccBranchType
mempty = BranchType -> AccBranchType
AccBranchType BranchType
Remote

newtype AccRemoteName = AccRemoteName T.Text deriving (Int -> AccRemoteName -> String -> String
[AccRemoteName] -> String -> String
AccRemoteName -> String
(Int -> AccRemoteName -> String -> String)
-> (AccRemoteName -> String)
-> ([AccRemoteName] -> String -> String)
-> Show AccRemoteName
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [AccRemoteName] -> String -> String
$cshowList :: [AccRemoteName] -> String -> String
show :: AccRemoteName -> String
$cshow :: AccRemoteName -> String
showsPrec :: Int -> AccRemoteName -> String -> String
$cshowsPrec :: Int -> AccRemoteName -> String -> String
Show)

instance Semigroup AccRemoteName where
  (AccRemoteName "origin/") <> :: AccRemoteName -> AccRemoteName -> AccRemoteName
<> r :: AccRemoteName
r = AccRemoteName
r
  l :: AccRemoteName
l <> _ = AccRemoteName
l

instance Monoid AccRemoteName where
  mempty :: AccRemoteName
mempty = Text -> AccRemoteName
AccRemoteName "origin/"

newtype AccMaster = AccMaster T.Text deriving (Int -> AccMaster -> String -> String
[AccMaster] -> String -> String
AccMaster -> String
(Int -> AccMaster -> String -> String)
-> (AccMaster -> String)
-> ([AccMaster] -> String -> String)
-> Show AccMaster
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [AccMaster] -> String -> String
$cshowList :: [AccMaster] -> String -> String
show :: AccMaster -> String
$cshow :: AccMaster -> String
showsPrec :: Int -> AccMaster -> String -> String
$cshowsPrec :: Int -> AccMaster -> String -> String
Show)

instance Semigroup AccMaster where
  (AccMaster "origin/master") <> :: AccMaster -> AccMaster -> AccMaster
<> r :: AccMaster
r = AccMaster
r
  l :: AccMaster
l <> _ = AccMaster
l

instance Monoid AccMaster where
  mempty :: AccMaster
mempty = Text -> AccMaster
AccMaster "origin/master"

data Acc
  = Acc
      { Acc -> Maybe Text
accGrep :: Maybe T.Text,
        Acc -> Maybe String
accPath :: Maybe IO.FilePath,
        Acc -> AccLimit
accLimit :: AccLimit,
        Acc -> AccBranchType
accBranchType :: AccBranchType,
        Acc -> AccRemoteName
accRemoteName :: AccRemoteName,
        Acc -> AccMaster
accMaster :: AccMaster
      }

instance Semigroup Acc where
  Acc
    { accGrep :: Acc -> Maybe Text
accGrep = Maybe Text
g,
      accPath :: Acc -> Maybe String
accPath = Maybe String
p,
      accLimit :: Acc -> AccLimit
accLimit = AccLimit
l,
      accBranchType :: Acc -> AccBranchType
accBranchType = AccBranchType
b,
      accRemoteName :: Acc -> AccRemoteName
accRemoteName = AccRemoteName
r,
      accMaster :: Acc -> AccMaster
accMaster = AccMaster
m
    }
    <> :: Acc -> Acc -> Acc
<> Acc
      { accGrep :: Acc -> Maybe Text
accGrep = Maybe Text
g',
        accPath :: Acc -> Maybe String
accPath = Maybe String
p',
        accLimit :: Acc -> AccLimit
accLimit = AccLimit
l',
        accBranchType :: Acc -> AccBranchType
accBranchType = AccBranchType
b',
        accRemoteName :: Acc -> AccRemoteName
accRemoteName = AccRemoteName
r',
        accMaster :: Acc -> AccMaster
accMaster = AccMaster
m'
      } =
      Maybe Text
-> Maybe String
-> AccLimit
-> AccBranchType
-> AccRemoteName
-> AccMaster
-> Acc
Acc (Maybe Text
g Maybe Text -> Maybe Text -> Maybe Text
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Maybe Text
g') (Maybe String
p Maybe String -> Maybe String -> Maybe String
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Maybe String
p') (AccLimit
l AccLimit -> AccLimit -> AccLimit
forall a. Semigroup a => a -> a -> a
<> AccLimit
l') (AccBranchType
b AccBranchType -> AccBranchType -> AccBranchType
forall a. Semigroup a => a -> a -> a
<> AccBranchType
b') (AccRemoteName
r AccRemoteName -> AccRemoteName -> AccRemoteName
forall a. Semigroup a => a -> a -> a
<> AccRemoteName
r') (AccMaster
m AccMaster -> AccMaster -> AccMaster
forall a. Semigroup a => a -> a -> a
<> AccMaster
m')

instance Monoid Acc where
  mempty :: Acc
mempty = Maybe Text
-> Maybe String
-> AccLimit
-> AccBranchType
-> AccRemoteName
-> AccMaster
-> Acc
Acc Maybe Text
forall a. Monoid a => a
mempty Maybe String
forall a. Monoid a => a
mempty AccLimit
forall a. Monoid a => a
mempty AccBranchType
forall a. Monoid a => a
mempty AccRemoteName
forall a. Monoid a => a
mempty AccMaster
forall a. Monoid a => a
mempty

accToEnv :: Cal.Day -> Acc -> Env
accToEnv :: Day -> Acc -> Env
accToEnv
  d :: Day
d
  ( Acc
      { Maybe Text
accGrep :: Maybe Text
accGrep :: Acc -> Maybe Text
accGrep,
        Maybe String
accPath :: Maybe String
accPath :: Acc -> Maybe String
accPath,
        accLimit :: Acc -> AccLimit
accLimit = (AccLimit l :: RNonNegative Int
l),
        accBranchType :: Acc -> AccBranchType
accBranchType = (AccBranchType b :: BranchType
b),
        accRemoteName :: Acc -> AccRemoteName
accRemoteName = (AccRemoteName r :: Text
r),
        accMaster :: Acc -> AccMaster
accMaster = (AccMaster m :: Text
m)
      }
    ) =
    Env :: Maybe Text
-> Maybe String
-> RNonNegative Int
-> BranchType
-> Text
-> Text
-> Day
-> Env
Env
      { grepStr :: Maybe Text
grepStr = Maybe Text
accGrep,
        path :: Maybe String
path = Maybe String
accPath,
        limit :: RNonNegative Int
limit = RNonNegative Int
l,
        branchType :: BranchType
branchType = BranchType
b,
        remoteName :: Text
remoteName = Text
r,
        master :: Text
master = Text
m,
        today :: Day
today = Day
d
      }

allParsers :: [AnyParser Acc]
allParsers :: [AnyParser Acc]
allParsers =
  [ AnyParser Acc
grepParser,
    AnyParser Acc
pathParser,
    AnyParser Acc
limitParser,
    AnyParser Acc
branchTypeParser,
    AnyParser Acc
branchFlagParser,
    AnyParser Acc
remoteNameParser,
    AnyParser Acc
masterParser
  ]

grepParser :: AnyParser Acc
grepParser :: AnyParser Acc
grepParser = Parser (Maybe Text) Acc -> AnyParser Acc
forall acc a. Parser a acc -> AnyParser acc
AnyParser (Parser (Maybe Text) Acc -> AnyParser Acc)
-> Parser (Maybe Text) Acc -> AnyParser Acc
forall a b. (a -> b) -> a -> b
$ (String, String -> Maybe (Maybe Text), Acc -> Maybe Text -> Acc)
-> Parser (Maybe Text) Acc
forall a acc.
(String, String -> Maybe a, acc -> a -> acc) -> Parser a acc
PrefixParser ("--grep=", String -> Maybe (Maybe Text)
parser, Acc -> Maybe Text -> Acc
updater)
  where
    parser :: String -> Maybe (Maybe Text)
parser "" = Maybe Text -> Maybe (Maybe Text)
forall a. a -> Maybe a
Just Maybe Text
forall a. Maybe a
Nothing
    parser s :: String
s = Maybe Text -> Maybe (Maybe Text)
forall a. a -> Maybe a
Just (Maybe Text -> Maybe (Maybe Text))
-> Maybe Text -> Maybe (Maybe Text)
forall a b. (a -> b) -> a -> b
$ Text -> Maybe Text
forall a. a -> Maybe a
Just (Text -> Maybe Text) -> Text -> Maybe Text
forall a b. (a -> b) -> a -> b
$ String -> Text
T.pack String
s
    updater :: Acc -> Maybe Text -> Acc
updater acc :: Acc
acc g :: Maybe Text
g = Acc
acc {accGrep :: Maybe Text
accGrep = Maybe Text
g}

pathParser :: AnyParser Acc
pathParser :: AnyParser Acc
pathParser = Parser (Maybe String) Acc -> AnyParser Acc
forall acc a. Parser a acc -> AnyParser acc
AnyParser (Parser (Maybe String) Acc -> AnyParser Acc)
-> Parser (Maybe String) Acc -> AnyParser Acc
forall a b. (a -> b) -> a -> b
$ (String, String -> Maybe (Maybe String),
 Acc -> Maybe String -> Acc)
-> Parser (Maybe String) Acc
forall a acc.
(String, String -> Maybe a, acc -> a -> acc) -> Parser a acc
PrefixParser ("--path=", String -> Maybe (Maybe String)
forall a. (Eq a, IsString a) => a -> Maybe (Maybe a)
parser, Acc -> Maybe String -> Acc
updater)
  where
    parser :: a -> Maybe (Maybe a)
parser "" = Maybe a -> Maybe (Maybe a)
forall a. a -> Maybe a
Just Maybe a
forall a. Maybe a
Nothing
    parser s :: a
s = Maybe a -> Maybe (Maybe a)
forall a. a -> Maybe a
Just (Maybe a -> Maybe (Maybe a)) -> Maybe a -> Maybe (Maybe a)
forall a b. (a -> b) -> a -> b
$ a -> Maybe a
forall a. a -> Maybe a
Just a
s
    updater :: Acc -> Maybe String -> Acc
updater acc :: Acc
acc p :: Maybe String
p = Acc
acc {accPath :: Maybe String
accPath = Maybe String
p}

limitParser :: AnyParser Acc
limitParser :: AnyParser Acc
limitParser = Parser AccLimit Acc -> AnyParser Acc
forall acc a. Parser a acc -> AnyParser acc
AnyParser (Parser AccLimit Acc -> AnyParser Acc)
-> Parser AccLimit Acc -> AnyParser Acc
forall a b. (a -> b) -> a -> b
$ (String, String -> Maybe AccLimit, Acc -> AccLimit -> Acc)
-> Parser AccLimit Acc
forall a acc.
(String, String -> Maybe a, acc -> a -> acc) -> Parser a acc
PrefixParser ("--limit=", String -> Maybe AccLimit
parser, Acc -> AccLimit -> Acc
updater)
  where
    parser :: String -> Maybe AccLimit
parser s :: String
s =
      let readAndRefine :: String -> Maybe (RNonNegative Int)
readAndRefine = (String -> Either String Int)
-> (Int -> Either RefineException (RNonNegative Int))
-> String
-> Maybe (RNonNegative Int)
forall a b c d e.
(a -> Either b c) -> (c -> Either d e) -> a -> Maybe e
eitherComposeMay String -> Either String Int
forall a. Read a => String -> Either String a
TR.readEither Int -> Either RefineException (RNonNegative Int)
forall p x.
Predicate p x =>
x -> Either RefineException (Refined p x)
refine
       in RNonNegative Int -> AccLimit
AccLimit (RNonNegative Int -> AccLimit)
-> Maybe (RNonNegative Int) -> Maybe AccLimit
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> String -> Maybe (RNonNegative Int)
readAndRefine String
s
    updater :: Acc -> AccLimit -> Acc
updater acc :: Acc
acc l :: AccLimit
l = Acc
acc {accLimit :: AccLimit
accLimit = AccLimit
l}

branchTypeParser :: AnyParser Acc
branchTypeParser :: AnyParser Acc
branchTypeParser = Parser AccBranchType Acc -> AnyParser Acc
forall acc a. Parser a acc -> AnyParser acc
AnyParser (Parser AccBranchType Acc -> AnyParser Acc)
-> Parser AccBranchType Acc -> AnyParser Acc
forall a b. (a -> b) -> a -> b
$ (String, String -> Maybe AccBranchType,
 Acc -> AccBranchType -> Acc)
-> Parser AccBranchType Acc
forall a acc.
(String, String -> Maybe a, acc -> a -> acc) -> Parser a acc
PrefixParser ("--branch-type=", String -> Maybe AccBranchType
forall a. (Eq a, IsString a) => a -> Maybe AccBranchType
parser, Acc -> AccBranchType -> Acc
updater)
  where
    parser :: a -> Maybe AccBranchType
parser "all" = AccBranchType -> Maybe AccBranchType
forall a. a -> Maybe a
Just (AccBranchType -> Maybe AccBranchType)
-> AccBranchType -> Maybe AccBranchType
forall a b. (a -> b) -> a -> b
$ BranchType -> AccBranchType
AccBranchType BranchType
All
    parser "remote" = AccBranchType -> Maybe AccBranchType
forall a. a -> Maybe a
Just (AccBranchType -> Maybe AccBranchType)
-> AccBranchType -> Maybe AccBranchType
forall a b. (a -> b) -> a -> b
$ BranchType -> AccBranchType
AccBranchType BranchType
Remote
    parser "local" = AccBranchType -> Maybe AccBranchType
forall a. a -> Maybe a
Just (AccBranchType -> Maybe AccBranchType)
-> AccBranchType -> Maybe AccBranchType
forall a b. (a -> b) -> a -> b
$ BranchType -> AccBranchType
AccBranchType BranchType
Local
    parser _ = Maybe AccBranchType
forall a. Maybe a
Nothing
    updater :: Acc -> AccBranchType -> Acc
updater acc :: Acc
acc b :: AccBranchType
b = Acc
acc {accBranchType :: AccBranchType
accBranchType = AccBranchType
b}

branchFlagParser :: AnyParser Acc
branchFlagParser :: AnyParser Acc
branchFlagParser = Parser AccBranchType Acc -> AnyParser Acc
forall acc a. Parser a acc -> AnyParser acc
AnyParser (Parser AccBranchType Acc -> AnyParser Acc)
-> Parser AccBranchType Acc -> AnyParser Acc
forall a b. (a -> b) -> a -> b
$ (String -> Maybe AccBranchType, Acc -> AccBranchType -> Acc)
-> Parser AccBranchType Acc
forall a acc. (String -> Maybe a, acc -> a -> acc) -> Parser a acc
ExactParser (String -> Maybe AccBranchType
forall a. (Eq a, IsString a) => a -> Maybe AccBranchType
parser, Acc -> AccBranchType -> Acc
updater)
  where
    parser :: a -> Maybe AccBranchType
parser "-a" = AccBranchType -> Maybe AccBranchType
forall a. a -> Maybe a
Just (AccBranchType -> Maybe AccBranchType)
-> AccBranchType -> Maybe AccBranchType
forall a b. (a -> b) -> a -> b
$ BranchType -> AccBranchType
AccBranchType BranchType
All
    parser "-r" = AccBranchType -> Maybe AccBranchType
forall a. a -> Maybe a
Just (AccBranchType -> Maybe AccBranchType)
-> AccBranchType -> Maybe AccBranchType
forall a b. (a -> b) -> a -> b
$ BranchType -> AccBranchType
AccBranchType BranchType
Remote
    parser "-l" = AccBranchType -> Maybe AccBranchType
forall a. a -> Maybe a
Just (AccBranchType -> Maybe AccBranchType)
-> AccBranchType -> Maybe AccBranchType
forall a b. (a -> b) -> a -> b
$ BranchType -> AccBranchType
AccBranchType BranchType
Local
    parser _ = Maybe AccBranchType
forall a. Maybe a
Nothing
    updater :: Acc -> AccBranchType -> Acc
updater acc :: Acc
acc b :: AccBranchType
b = Acc
acc {accBranchType :: AccBranchType
accBranchType = AccBranchType
b}

remoteNameParser :: AnyParser Acc
remoteNameParser :: AnyParser Acc
remoteNameParser = Parser AccRemoteName Acc -> AnyParser Acc
forall acc a. Parser a acc -> AnyParser acc
AnyParser (Parser AccRemoteName Acc -> AnyParser Acc)
-> Parser AccRemoteName Acc -> AnyParser Acc
forall a b. (a -> b) -> a -> b
$ (String, String -> Maybe AccRemoteName,
 Acc -> AccRemoteName -> Acc)
-> Parser AccRemoteName Acc
forall a acc.
(String, String -> Maybe a, acc -> a -> acc) -> Parser a acc
PrefixParser ("--remote=", String -> Maybe AccRemoteName
parser, Acc -> AccRemoteName -> Acc
updater)
  where
    parser :: String -> Maybe AccRemoteName
parser "" = AccRemoteName -> Maybe AccRemoteName
forall a. a -> Maybe a
Just (AccRemoteName -> Maybe AccRemoteName)
-> AccRemoteName -> Maybe AccRemoteName
forall a b. (a -> b) -> a -> b
$ Text -> AccRemoteName
AccRemoteName ""
    parser s :: String
s = AccRemoteName -> Maybe AccRemoteName
forall a. a -> Maybe a
Just (AccRemoteName -> Maybe AccRemoteName)
-> AccRemoteName -> Maybe AccRemoteName
forall a b. (a -> b) -> a -> b
$ Text -> AccRemoteName
AccRemoteName (Text -> AccRemoteName) -> Text -> AccRemoteName
forall a b. (a -> b) -> a -> b
$ String -> Text
T.pack (String
s String -> String -> String
forall a. Semigroup a => a -> a -> a
<> "/")
    updater :: Acc -> AccRemoteName -> Acc
updater acc :: Acc
acc r :: AccRemoteName
r = Acc
acc {accRemoteName :: AccRemoteName
accRemoteName = AccRemoteName
r}

masterParser :: AnyParser Acc
masterParser :: AnyParser Acc
masterParser = Parser AccMaster Acc -> AnyParser Acc
forall acc a. Parser a acc -> AnyParser acc
AnyParser (Parser AccMaster Acc -> AnyParser Acc)
-> Parser AccMaster Acc -> AnyParser Acc
forall a b. (a -> b) -> a -> b
$ (String, String -> Maybe AccMaster, Acc -> AccMaster -> Acc)
-> Parser AccMaster Acc
forall a acc.
(String, String -> Maybe a, acc -> a -> acc) -> Parser a acc
PrefixParser ("--master=", String -> Maybe AccMaster
parser, Acc -> AccMaster -> Acc
updater)
  where
    parser :: String -> Maybe AccMaster
parser "" = AccMaster -> Maybe AccMaster
forall a. a -> Maybe a
Just (AccMaster -> Maybe AccMaster) -> AccMaster -> Maybe AccMaster
forall a b. (a -> b) -> a -> b
$ Text -> AccMaster
AccMaster ""
    parser s :: String
s = AccMaster -> Maybe AccMaster
forall a. a -> Maybe a
Just (AccMaster -> Maybe AccMaster) -> AccMaster -> Maybe AccMaster
forall a b. (a -> b) -> a -> b
$ Text -> AccMaster
AccMaster (Text -> AccMaster) -> Text -> AccMaster
forall a b. (a -> b) -> a -> b
$ String -> Text
T.pack String
s
    updater :: Acc -> AccMaster -> Acc
updater acc :: Acc
acc m :: AccMaster
m = Acc
acc {accMaster :: AccMaster
accMaster = AccMaster
m}

help :: String
help :: String
help =
  "\nUsage: cli-utils find-stale [OPTIONS]\n\n"
    String -> String -> String
forall a. Semigroup a => a -> a -> a
<> "Displays stale branches.\n\nOptions:\n"
    String -> String -> String
forall a. Semigroup a => a -> a -> a
<> "  --grep=<string>\t\tFilters branch names based on <string>.\n\n"
    String -> String -> String
forall a. Semigroup a => a -> a -> a
<> "  --path=<string>\t\tDirectory path, defaults to current directory.\n\n"
    String -> String -> String
forall a. Semigroup a => a -> a -> a
<> "  --limit=<days>\t\tNon-negative integer s.t. branch is stale iff last_commit(branch) >= <days>\n\n"
    String -> String -> String
forall a. Semigroup a => a -> a -> a
<> "  -a, --branch-type=all\t\tSearches all branches.\n\n"
    String -> String -> String
forall a. Semigroup a => a -> a -> a
<> "  -r, --branch-type=remote\tSearches remote branches only. This is the default.\n\n"
    String -> String -> String
forall a. Semigroup a => a -> a -> a
<> "  -l, --branch-type=local\tSearches local branches only.\n\n"
    String -> String -> String
forall a. Semigroup a => a -> a -> a
<> "  --remote=<string>\t\tName of the remote, used for stripping when displaying. Defaults to origin.\n\n"
    String -> String -> String
forall a. Semigroup a => a -> a -> a
<> "  --master=<string>\t\tName of the branch to consider merges against. Defaults to origin/master.\n\n"