{-# LANGUAGE NoImplicitPrelude #-}

module Stack.Options.PackageParser where

import qualified Data.Map                          as Map
import           Options.Applicative
import           Options.Applicative.Types         (readerAsk)
import           Stack.Prelude
import           Stack.Types.Config.Build (ApplyCLIFlag (..))

-- | Parser for package:[-]flag

readFlag :: ReadM (Map ApplyCLIFlag (Map FlagName Bool))
readFlag :: ReadM (Map ApplyCLIFlag (Map FlagName Bool))
readFlag = do
    [Char]
s <- ReadM [Char]
readerAsk
    case forall a. (a -> Bool) -> [a] -> ([a], [a])
break (forall a. Eq a => a -> a -> Bool
== Char
':') [Char]
s of
        ([Char]
pn, Char
':':[Char]
mflag) -> do
            ApplyCLIFlag
pn' <-
                case [Char] -> Maybe PackageName
parsePackageName [Char]
pn of
                    Maybe PackageName
Nothing
                        | [Char]
pn forall a. Eq a => a -> a -> Bool
== [Char]
"*" -> forall (m :: * -> *) a. Monad m => a -> m a
return ApplyCLIFlag
ACFAllProjectPackages
                        | Bool
otherwise -> forall a. [Char] -> ReadM a
readerError forall a b. (a -> b) -> a -> b
$ [Char]
"Invalid package name: " forall a. [a] -> [a] -> [a]
++ [Char]
pn
                    Just PackageName
x -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ PackageName -> ApplyCLIFlag
ACFByName PackageName
x
            let (Bool
b, [Char]
flagS) =
                    case [Char]
mflag of
                        Char
'-':[Char]
x -> (Bool
False, [Char]
x)
                        [Char]
_ -> (Bool
True, [Char]
mflag)
            FlagName
flagN <-
                case [Char] -> Maybe FlagName
parseFlagName [Char]
flagS of
                    Maybe FlagName
Nothing -> forall a. [Char] -> ReadM a
readerError forall a b. (a -> b) -> a -> b
$ [Char]
"Invalid flag name: " forall a. [a] -> [a] -> [a]
++ [Char]
flagS
                    Just FlagName
x -> forall (m :: * -> *) a. Monad m => a -> m a
return FlagName
x
            forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall k a. k -> a -> Map k a
Map.singleton ApplyCLIFlag
pn' forall a b. (a -> b) -> a -> b
$ forall k a. k -> a -> Map k a
Map.singleton FlagName
flagN Bool
b
        ([Char], [Char])
_ -> forall a. [Char] -> ReadM a
readerError [Char]
"Must have a colon"