module Options.Tokenize
( Token (..),
tokenFlagName,
Tokens (..),
tokensMap,
tokenize,
)
where
import Control.Monad.Except hiding (throwError)
import qualified Control.Monad.Except
import Control.Monad.State
import Data.Functor.Identity
import qualified Data.Map
import Options.Types
import Options.Util
data Token
= TokenUnary String
| Token String String
deriving (Token -> Token -> Bool
(Token -> Token -> Bool) -> (Token -> Token -> Bool) -> Eq Token
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Token -> Token -> Bool
== :: Token -> Token -> Bool
$c/= :: Token -> Token -> Bool
/= :: Token -> Token -> Bool
Eq, Int -> Token -> ShowS
[Token] -> ShowS
Token -> String
(Int -> Token -> ShowS)
-> (Token -> String) -> ([Token] -> ShowS) -> Show Token
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Token -> ShowS
showsPrec :: Int -> Token -> ShowS
$cshow :: Token -> String
show :: Token -> String
$cshowList :: [Token] -> ShowS
showList :: [Token] -> ShowS
Show)
tokenFlagName :: Token -> String
tokenFlagName :: Token -> String
tokenFlagName (TokenUnary String
s) = String
s
tokenFlagName (Token String
s String
_) = String
s
data Tokens = Tokens
{ Tokens -> [([OptionKey], Token)]
tokensList :: [([OptionKey], Token)],
Tokens -> [String]
tokensArgv :: [String]
}
deriving (Int -> Tokens -> ShowS
[Tokens] -> ShowS
Tokens -> String
(Int -> Tokens -> ShowS)
-> (Tokens -> String) -> ([Tokens] -> ShowS) -> Show Tokens
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Tokens -> ShowS
showsPrec :: Int -> Tokens -> ShowS
$cshow :: Tokens -> String
show :: Tokens -> String
$cshowList :: [Tokens] -> ShowS
showList :: [Tokens] -> ShowS
Show)
tokensMap :: Tokens -> Data.Map.Map OptionKey [Token]
tokensMap :: Tokens -> Map OptionKey [Token]
tokensMap Tokens
tokens = ([Token] -> [Token] -> [Token])
-> [(OptionKey, [Token])] -> Map OptionKey [Token]
forall k a. Ord k => (a -> a -> a) -> [(k, a)] -> Map k a
Data.Map.fromListWith (\[Token]
xs [Token]
ys -> [Token]
ys [Token] -> [Token] -> [Token]
forall a. [a] -> [a] -> [a]
++ [Token]
xs) do
([OptionKey]
keys, Token
token) <- Tokens -> [([OptionKey], Token)]
tokensList Tokens
tokens
OptionKey
key <- [OptionKey]
keys
(OptionKey, [Token]) -> [(OptionKey, [Token])]
forall a. a -> [a]
forall (m :: * -> *) a. Monad m => a -> m a
return (OptionKey
key, [Token
token])
data TokState = TokState
{ TokState -> [String]
stArgv :: [String],
TokState -> [String]
stArgs :: [String],
TokState -> [([OptionKey], Token)]
stOpts :: [([OptionKey], Token)],
TokState -> Map Char ([OptionKey], OptionInfo)
stShortKeys :: Data.Map.Map Char ([OptionKey], OptionInfo),
TokState -> Map String ([OptionKey], OptionInfo)
stLongKeys :: Data.Map.Map String ([OptionKey], OptionInfo),
TokState -> [(String, [OptionInfo])]
stSubcommands :: [(String, [OptionInfo])],
TokState -> Maybe String
stSubCmd :: Maybe String
}
newtype Tok a = Tok {forall a. Tok a -> ExceptT String (StateT TokState Identity) a
unTok :: ExceptT String (StateT TokState Identity) a}
instance Functor Tok where
fmap :: forall a b. (a -> b) -> Tok a -> Tok b
fmap = (a -> b) -> Tok a -> Tok b
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM
instance Applicative Tok where
pure :: forall a. a -> Tok a
pure = ExceptT String (StateT TokState Identity) a -> Tok a
forall a. ExceptT String (StateT TokState Identity) a -> Tok a
Tok (ExceptT String (StateT TokState Identity) a -> Tok a)
-> (a -> ExceptT String (StateT TokState Identity) a) -> a -> Tok a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> ExceptT String (StateT TokState Identity) a
forall a. a -> ExceptT String (StateT TokState Identity) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure
<*> :: forall a b. Tok (a -> b) -> Tok a -> Tok b
(<*>) = Tok (a -> b) -> Tok a -> Tok b
forall (m :: * -> *) a b. Monad m => m (a -> b) -> m a -> m b
ap
instance Monad Tok where
Tok a
m >>= :: forall a b. Tok a -> (a -> Tok b) -> Tok b
>>= a -> Tok b
f = ExceptT String (StateT TokState Identity) b -> Tok b
forall a. ExceptT String (StateT TokState Identity) a -> Tok a
Tok (Tok a -> ExceptT String (StateT TokState Identity) a
forall a. Tok a -> ExceptT String (StateT TokState Identity) a
unTok Tok a
m ExceptT String (StateT TokState Identity) a
-> (a -> ExceptT String (StateT TokState Identity) b)
-> ExceptT String (StateT TokState Identity) b
forall a b.
ExceptT String (StateT TokState Identity) a
-> (a -> ExceptT String (StateT TokState Identity) b)
-> ExceptT String (StateT TokState Identity) b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Tok b -> ExceptT String (StateT TokState Identity) b
forall a. Tok a -> ExceptT String (StateT TokState Identity) a
unTok (Tok b -> ExceptT String (StateT TokState Identity) b)
-> (a -> Tok b) -> a -> ExceptT String (StateT TokState Identity) b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Tok b
f)
instance MonadState Tok where
type StateType Tok = TokState
get :: Tok (StateType Tok)
get = ExceptT String (StateT TokState Identity) TokState -> Tok TokState
forall a. ExceptT String (StateT TokState Identity) a -> Tok a
Tok ExceptT
String
(StateT TokState Identity)
(StateType (ExceptT String (StateT TokState Identity)))
ExceptT String (StateT TokState Identity) TokState
forall (m :: * -> *). MonadState m => m (StateType m)
get
put :: StateType Tok -> Tok ()
put = ExceptT String (StateT TokState Identity) () -> Tok ()
forall a. ExceptT String (StateT TokState Identity) a -> Tok a
Tok (ExceptT String (StateT TokState Identity) () -> Tok ())
-> (TokState -> ExceptT String (StateT TokState Identity) ())
-> TokState
-> Tok ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. StateType (ExceptT String (StateT TokState Identity))
-> ExceptT String (StateT TokState Identity) ()
TokState -> ExceptT String (StateT TokState Identity) ()
forall (m :: * -> *). MonadState m => StateType m -> m ()
put
tokenize :: OptionDefinitions -> [String] -> (Maybe String, Either String Tokens)
tokenize :: OptionDefinitions
-> [String] -> (Maybe String, Either String Tokens)
tokenize (OptionDefinitions [OptionInfo]
options [(String, [OptionInfo])]
subcommands) [String]
argv = Identity (Maybe String, Either String Tokens)
-> (Maybe String, Either String Tokens)
forall a. Identity a -> a
runIdentity do
let st :: TokState
st =
TokState
{ stArgv :: [String]
stArgv = [String]
argv,
stArgs :: [String]
stArgs = [],
stOpts :: [([OptionKey], Token)]
stOpts = [],
stShortKeys :: Map Char ([OptionKey], OptionInfo)
stShortKeys = [OptionInfo] -> Map Char ([OptionKey], OptionInfo)
toShortKeys [OptionInfo]
options,
stLongKeys :: Map String ([OptionKey], OptionInfo)
stLongKeys = [OptionInfo] -> Map String ([OptionKey], OptionInfo)
toLongKeys [OptionInfo]
options,
stSubcommands :: [(String, [OptionInfo])]
stSubcommands = [(String, [OptionInfo])]
subcommands,
stSubCmd :: Maybe String
stSubCmd = Maybe String
forall a. Maybe a
Nothing
}
(Either String ()
err, TokState
st') <- StateT TokState Identity (Either String ())
-> TokState -> Identity (Either String (), TokState)
forall s (m :: * -> *) a. StateT s m a -> s -> m (a, s)
runStateT (ExceptT String (StateT TokState Identity) ()
-> StateT TokState Identity (Either String ())
forall e (m :: * -> *) a. ExceptT e m a -> m (Either e a)
runExceptT (Tok () -> ExceptT String (StateT TokState Identity) ()
forall a. Tok a -> ExceptT String (StateT TokState Identity) a
unTok Tok ()
loop)) TokState
st
(Maybe String, Either String Tokens)
-> Identity (Maybe String, Either String Tokens)
forall a. a -> Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return
( TokState -> Maybe String
stSubCmd TokState
st',
case Either String ()
err of
Left String
err' -> String -> Either String Tokens
forall a b. a -> Either a b
Left String
err'
Right ()
_ -> Tokens -> Either String Tokens
forall a b. b -> Either a b
Right ([([OptionKey], Token)] -> [String] -> Tokens
Tokens ([([OptionKey], Token)] -> [([OptionKey], Token)]
forall a. [a] -> [a]
reverse (TokState -> [([OptionKey], Token)]
stOpts TokState
st')) (TokState -> [String]
stArgs TokState
st'))
)
loop :: Tok ()
loop :: Tok ()
loop = do
Maybe String
ms <- Tok (Maybe String)
nextItem
TokState
st <- Tok (StateType Tok)
Tok TokState
forall (m :: * -> *). MonadState m => m (StateType m)
get
case Maybe String
ms of
Maybe String
Nothing -> () -> Tok ()
forall a. a -> Tok a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
Just String
s -> (Tok () -> Tok () -> Tok ()
forall a b. Tok a -> Tok b -> Tok b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Tok ()
loop) case ShowS
stringToGhc704 String
s of
Char
'-' : Char
'-' : [] -> StateType Tok -> Tok ()
forall (m :: * -> *). MonadState m => StateType m -> m ()
put (TokState
st {stArgv = [], stArgs = stArgs st ++ stArgv st})
Char
'-' : Char
'-' : String
opt -> String -> Tok ()
parseLong String
opt
Char
'-' : Char
optChar : String
optValue -> Char -> String -> Tok ()
parseShort Char
optChar String
optValue
Char
'-' : [] -> String -> Tok ()
addArg String
s
String
decoded -> case (TokState -> [(String, [OptionInfo])]
stSubcommands TokState
st, TokState -> Maybe String
stSubCmd TokState
st) of
([], Maybe String
_) -> String -> Tok ()
addArg String
s
([(String, [OptionInfo])]
_, Just String
_) -> String -> Tok ()
addArg String
s
([(String, [OptionInfo])]
_, Maybe String
Nothing) -> case String -> [(String, [OptionInfo])] -> Maybe [OptionInfo]
forall a b. Eq a => a -> [(a, b)] -> Maybe b
lookup String
decoded (TokState -> [(String, [OptionInfo])]
stSubcommands TokState
st) of
Maybe [OptionInfo]
Nothing -> String -> Tok ()
forall a. String -> Tok a
throwError (String
"Unknown subcommand " String -> ShowS
forall a. [a] -> [a] -> [a]
++ ShowS
forall a. Show a => a -> String
show String
decoded String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
".")
Just [OptionInfo]
subOptions -> String -> [OptionInfo] -> Tok ()
mergeSubcommand String
decoded [OptionInfo]
subOptions
nextItem :: Tok (Maybe String)
nextItem :: Tok (Maybe String)
nextItem = do
TokState
st <- Tok (StateType Tok)
Tok TokState
forall (m :: * -> *). MonadState m => m (StateType m)
get
case TokState -> [String]
stArgv TokState
st of
[] -> Maybe String -> Tok (Maybe String)
forall a. a -> Tok a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe String
forall a. Maybe a
Nothing
(String
x : [String]
xs) -> do
StateType Tok -> Tok ()
forall (m :: * -> *). MonadState m => StateType m -> m ()
put (TokState
st {stArgv = xs})
Maybe String -> Tok (Maybe String)
forall a. a -> Tok a
forall (m :: * -> *) a. Monad m => a -> m a
return (String -> Maybe String
forall a. a -> Maybe a
Just String
x)
addArg :: String -> Tok ()
addArg :: String -> Tok ()
addArg String
s = (StateType Tok -> StateType Tok) -> Tok ()
forall (m :: * -> *).
MonadState m =>
(StateType m -> StateType m) -> m ()
modify (\StateType Tok
st -> StateType Tok
st {stArgs = stArgs st ++ [s]})
addOpt :: [OptionKey] -> Token -> Tok ()
addOpt :: [OptionKey] -> Token -> Tok ()
addOpt [OptionKey]
keys Token
val =
(StateType Tok -> StateType Tok) -> Tok ()
forall (m :: * -> *).
MonadState m =>
(StateType m -> StateType m) -> m ()
modify
( \StateType Tok
st ->
StateType Tok
st
{ stOpts = (keys, val) : stOpts st
}
)
mergeSubcommand :: String -> [OptionInfo] -> Tok ()
mergeSubcommand :: String -> [OptionInfo] -> Tok ()
mergeSubcommand String
name [OptionInfo]
opts = (StateType Tok -> StateType Tok) -> Tok ()
forall (m :: * -> *).
MonadState m =>
(StateType m -> StateType m) -> m ()
modify \StateType Tok
st ->
StateType Tok
st
{ stSubCmd = Just name,
stShortKeys = Data.Map.unionWith unionKeys (stShortKeys st) (toShortKeys opts),
stLongKeys = Data.Map.unionWith unionKeys (stLongKeys st) (toLongKeys opts)
}
unionKeys :: ([OptionKey], OptionInfo) -> ([OptionKey], OptionInfo) -> ([OptionKey], OptionInfo)
unionKeys :: ([OptionKey], OptionInfo)
-> ([OptionKey], OptionInfo) -> ([OptionKey], OptionInfo)
unionKeys ([OptionKey]
keys1, OptionInfo
info) ([OptionKey]
keys2, OptionInfo
_) = ([OptionKey]
keys1 [OptionKey] -> [OptionKey] -> [OptionKey]
forall a. [a] -> [a] -> [a]
++ [OptionKey]
keys2, OptionInfo
info)
parseLong :: String -> Tok ()
parseLong :: String -> Tok ()
parseLong String
optName = do
Map String ([OptionKey], OptionInfo)
longKeys <- (StateType Tok -> Map String ([OptionKey], OptionInfo))
-> Tok (Map String ([OptionKey], OptionInfo))
forall (m :: * -> *) a. MonadState m => (StateType m -> a) -> m a
gets StateType Tok -> Map String ([OptionKey], OptionInfo)
TokState -> Map String ([OptionKey], OptionInfo)
stLongKeys
case (Char -> Bool) -> String -> (String, String)
forall a. (a -> Bool) -> [a] -> ([a], [a])
break (Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
'=') String
optName of
(String
before, String
after) -> case String
after of
Char
'=' : String
value -> case String
-> Map String ([OptionKey], OptionInfo)
-> Maybe ([OptionKey], OptionInfo)
forall k a. Ord k => k -> Map k a -> Maybe a
Data.Map.lookup String
before Map String ([OptionKey], OptionInfo)
longKeys of
Maybe ([OptionKey], OptionInfo)
Nothing -> String -> Tok ()
forall a. String -> Tok a
throwError (String
"Unknown flag --" String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
before)
Just ([OptionKey]
keys, OptionInfo
info) ->
if OptionInfo -> Bool
optionInfoUnaryOnly OptionInfo
info
then String -> Tok ()
forall a. String -> Tok a
throwError (String
"Flag --" String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
before String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
" takes no parameters.")
else [OptionKey] -> Token -> Tok ()
addOpt [OptionKey]
keys (String -> String -> Token
Token (String
"--" String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
before) String
value)
String
_ -> case String
-> Map String ([OptionKey], OptionInfo)
-> Maybe ([OptionKey], OptionInfo)
forall k a. Ord k => k -> Map k a -> Maybe a
Data.Map.lookup String
optName Map String ([OptionKey], OptionInfo)
longKeys of
Maybe ([OptionKey], OptionInfo)
Nothing -> String -> Tok ()
forall a. String -> Tok a
throwError (String
"Unknown flag --" String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
optName)
Just ([OptionKey]
keys, OptionInfo
info) ->
if OptionInfo -> Bool
optionInfoUnary OptionInfo
info
then [OptionKey] -> Token -> Tok ()
addOpt [OptionKey]
keys (String -> Token
TokenUnary (String
"--" String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
optName))
else do
Maybe String
next <- Tok (Maybe String)
nextItem
case Maybe String
next of
Maybe String
Nothing -> String -> Tok ()
forall a. String -> Tok a
throwError (String
"The flag --" String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
optName String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
" requires a parameter.")
Just String
value -> [OptionKey] -> Token -> Tok ()
addOpt [OptionKey]
keys (String -> String -> Token
Token (String
"--" String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
optName) String
value)
parseShort :: Char -> String -> Tok ()
parseShort :: Char -> String -> Tok ()
parseShort Char
optChar String
optValue = do
let optName :: String
optName = Char
'-' Char -> ShowS
forall a. a -> [a] -> [a]
: [Char
optChar]
Map Char ([OptionKey], OptionInfo)
shortKeys <- (StateType Tok -> Map Char ([OptionKey], OptionInfo))
-> Tok (Map Char ([OptionKey], OptionInfo))
forall (m :: * -> *) a. MonadState m => (StateType m -> a) -> m a
gets StateType Tok -> Map Char ([OptionKey], OptionInfo)
TokState -> Map Char ([OptionKey], OptionInfo)
stShortKeys
case Char
-> Map Char ([OptionKey], OptionInfo)
-> Maybe ([OptionKey], OptionInfo)
forall k a. Ord k => k -> Map k a -> Maybe a
Data.Map.lookup Char
optChar Map Char ([OptionKey], OptionInfo)
shortKeys of
Maybe ([OptionKey], OptionInfo)
Nothing -> String -> Tok ()
forall a. String -> Tok a
throwError (String
"Unknown flag " String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
optName)
Just ([OptionKey]
keys, OptionInfo
info) ->
if OptionInfo -> Bool
optionInfoUnary OptionInfo
info
then
do
[OptionKey] -> Token -> Tok ()
addOpt [OptionKey]
keys (String -> Token
TokenUnary String
optName)
case String
optValue of
[] -> () -> Tok ()
forall a. a -> Tok a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
Char
nextChar : String
nextValue -> Char -> String -> Tok ()
parseShort Char
nextChar String
nextValue
else case String
optValue of
String
"" -> do
Maybe String
next <- Tok (Maybe String)
nextItem
case Maybe String
next of
Maybe String
Nothing -> String -> Tok ()
forall a. String -> Tok a
throwError (String
"The flag " String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
optName String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
" requires a parameter.")
Just String
value -> [OptionKey] -> Token -> Tok ()
addOpt [OptionKey]
keys (String -> String -> Token
Token String
optName String
value)
String
_ -> [OptionKey] -> Token -> Tok ()
addOpt [OptionKey]
keys (String -> String -> Token
Token String
optName String
optValue)
toShortKeys :: [OptionInfo] -> Data.Map.Map Char ([OptionKey], OptionInfo)
toShortKeys :: [OptionInfo] -> Map Char ([OptionKey], OptionInfo)
toShortKeys [OptionInfo]
opts = (([OptionKey], OptionInfo)
-> ([OptionKey], OptionInfo) -> ([OptionKey], OptionInfo))
-> [(Char, ([OptionKey], OptionInfo))]
-> Map Char ([OptionKey], OptionInfo)
forall k a. Ord k => (a -> a -> a) -> [(k, a)] -> Map k a
Data.Map.fromListWith (\([OptionKey]
keys1, OptionInfo
info) ([OptionKey]
keys2, OptionInfo
_) -> ([OptionKey]
keys2 [OptionKey] -> [OptionKey] -> [OptionKey]
forall a. [a] -> [a] -> [a]
++ [OptionKey]
keys1, OptionInfo
info)) do
OptionInfo
opt <- [OptionInfo]
opts
Char
flag <- OptionInfo -> String
optionInfoShortFlags OptionInfo
opt
(Char, ([OptionKey], OptionInfo))
-> [(Char, ([OptionKey], OptionInfo))]
forall a. a -> [a]
forall (m :: * -> *) a. Monad m => a -> m a
return (Char
flag, ([OptionInfo -> OptionKey
optionInfoKey OptionInfo
opt], OptionInfo
opt))
toLongKeys :: [OptionInfo] -> Data.Map.Map String ([OptionKey], OptionInfo)
toLongKeys :: [OptionInfo] -> Map String ([OptionKey], OptionInfo)
toLongKeys [OptionInfo]
opts = (([OptionKey], OptionInfo)
-> ([OptionKey], OptionInfo) -> ([OptionKey], OptionInfo))
-> [(String, ([OptionKey], OptionInfo))]
-> Map String ([OptionKey], OptionInfo)
forall k a. Ord k => (a -> a -> a) -> [(k, a)] -> Map k a
Data.Map.fromListWith (\([OptionKey]
keys1, OptionInfo
info) ([OptionKey]
keys2, OptionInfo
_) -> ([OptionKey]
keys2 [OptionKey] -> [OptionKey] -> [OptionKey]
forall a. [a] -> [a] -> [a]
++ [OptionKey]
keys1, OptionInfo
info)) do
OptionInfo
opt <- [OptionInfo]
opts
String
flag <- OptionInfo -> [String]
optionInfoLongFlags OptionInfo
opt
(String, ([OptionKey], OptionInfo))
-> [(String, ([OptionKey], OptionInfo))]
forall a. a -> [a]
forall (m :: * -> *) a. Monad m => a -> m a
return (String
flag, ([OptionInfo -> OptionKey
optionInfoKey OptionInfo
opt], OptionInfo
opt))
throwError :: String -> Tok a
throwError :: forall a. String -> Tok a
throwError = ExceptT String (StateT TokState Identity) a -> Tok a
forall a. ExceptT String (StateT TokState Identity) a -> Tok a
Tok (ExceptT String (StateT TokState Identity) a -> Tok a)
-> (String -> ExceptT String (StateT TokState Identity) a)
-> String
-> Tok a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> ExceptT String (StateT TokState Identity) a
ErrorType (ExceptT String (StateT TokState Identity))
-> ExceptT String (StateT TokState Identity) a
forall a.
ErrorType (ExceptT String (StateT TokState Identity))
-> ExceptT String (StateT TokState Identity) a
forall (m :: * -> *) a. MonadError m => ErrorType m -> m a
Control.Monad.Except.throwError