{-# LANGUAGE NoImplicitPrelude #-}

module Stack.Types.LockFileBehavior
  ( LockFileBehavior (..)
  , readLockFileBehavior
  ) where

import qualified Data.Map as Map
import           Options.Applicative ( ReadM )
import qualified Options.Applicative.Types as OA
import qualified RIO.List as List
import           Stack.Prelude

-- | How to interact with lock files

data LockFileBehavior
  = LFBReadWrite
    -- ^ Read and write lock files

  | LFBReadOnly
    -- ^ Read lock files, but do not write them

  | LFBIgnore
    -- ^ Entirely ignore lock files

  | LFBErrorOnWrite
    -- ^ Error out on trying to write a lock file. This can be used to

    -- ensure that lock files in a repository already ensure

    -- reproducible builds.

  deriving (LockFileBehavior
forall a. a -> a -> Bounded a
maxBound :: LockFileBehavior
$cmaxBound :: LockFileBehavior
minBound :: LockFileBehavior
$cminBound :: LockFileBehavior
Bounded, Int -> LockFileBehavior
LockFileBehavior -> Int
LockFileBehavior -> [LockFileBehavior]
LockFileBehavior -> LockFileBehavior
LockFileBehavior -> LockFileBehavior -> [LockFileBehavior]
LockFileBehavior
-> LockFileBehavior -> LockFileBehavior -> [LockFileBehavior]
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: LockFileBehavior
-> LockFileBehavior -> LockFileBehavior -> [LockFileBehavior]
$cenumFromThenTo :: LockFileBehavior
-> LockFileBehavior -> LockFileBehavior -> [LockFileBehavior]
enumFromTo :: LockFileBehavior -> LockFileBehavior -> [LockFileBehavior]
$cenumFromTo :: LockFileBehavior -> LockFileBehavior -> [LockFileBehavior]
enumFromThen :: LockFileBehavior -> LockFileBehavior -> [LockFileBehavior]
$cenumFromThen :: LockFileBehavior -> LockFileBehavior -> [LockFileBehavior]
enumFrom :: LockFileBehavior -> [LockFileBehavior]
$cenumFrom :: LockFileBehavior -> [LockFileBehavior]
fromEnum :: LockFileBehavior -> Int
$cfromEnum :: LockFileBehavior -> Int
toEnum :: Int -> LockFileBehavior
$ctoEnum :: Int -> LockFileBehavior
pred :: LockFileBehavior -> LockFileBehavior
$cpred :: LockFileBehavior -> LockFileBehavior
succ :: LockFileBehavior -> LockFileBehavior
$csucc :: LockFileBehavior -> LockFileBehavior
Enum, Int -> LockFileBehavior -> ShowS
[LockFileBehavior] -> ShowS
LockFileBehavior -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [LockFileBehavior] -> ShowS
$cshowList :: [LockFileBehavior] -> ShowS
show :: LockFileBehavior -> String
$cshow :: LockFileBehavior -> String
showsPrec :: Int -> LockFileBehavior -> ShowS
$cshowsPrec :: Int -> LockFileBehavior -> ShowS
Show)

-- | Parser for 'LockFileBehavior'

readLockFileBehavior :: ReadM LockFileBehavior
readLockFileBehavior :: ReadM LockFileBehavior
readLockFileBehavior = do
  String
s <- ReadM String
OA.readerAsk
  case forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup String
s Map String LockFileBehavior
m of
    Just LockFileBehavior
x -> forall (f :: * -> *) a. Applicative f => a -> f a
pure LockFileBehavior
x
    Maybe LockFileBehavior
Nothing -> forall a. String -> ReadM a
OA.readerError forall a b. (a -> b) -> a -> b
$ String
"Invalid lock file behavior, valid options: " forall a. [a] -> [a] -> [a]
++
                                forall a. [a] -> [[a]] -> [a]
List.intercalate String
", " (forall k a. Map k a -> [k]
Map.keys Map String LockFileBehavior
m)
 where
  m :: Map String LockFileBehavior
m = forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList forall a b. (a -> b) -> a -> b
$ forall a b. (a -> b) -> [a] -> [b]
map (\LockFileBehavior
x -> (LockFileBehavior -> String
render LockFileBehavior
x, LockFileBehavior
x)) [forall a. Bounded a => a
minBound..forall a. Bounded a => a
maxBound]
  render :: LockFileBehavior -> String
render LockFileBehavior
LFBReadWrite = String
"read-write"
  render LockFileBehavior
LFBReadOnly = String
"read-only"
  render LockFileBehavior
LFBIgnore = String
"ignore"
  render LockFileBehavior
LFBErrorOnWrite = String
"error-on-write"