{-# LANGUAGE NoImplicitPrelude #-}

module Stack.Options.PackageParser
  ( readFlag
  ) where

import qualified Data.Map as Map
import           Options.Applicative ( ReadM, readerError )
import           Options.Applicative.Types ( readerAsk )
import           Stack.Prelude
import           Stack.Types.BuildOpts ( 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 (f :: * -> *) a. Applicative f => a -> f a
pure 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 (f :: * -> *) a. Applicative f => a -> f a
pure 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 (f :: * -> *) a. Applicative f => a -> f a
pure FlagName
x
      forall (f :: * -> *) a. Applicative f => a -> f a
pure 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."