module CabalGild.Unstable.Type.Pragma where

import qualified Control.Monad as Monad
import qualified Distribution.Compat.CharParsing as CharParsing
import qualified Distribution.FieldGrammar.Newtypes as Newtypes
import qualified Distribution.Parsec as Parsec

-- | A pragma, which is a special comment used to customize behavior.
newtype Pragma
  = -- | Discover modules using the given arguments.
    Discover [String]
  deriving (Pragma -> Pragma -> Bool
(Pragma -> Pragma -> Bool)
-> (Pragma -> Pragma -> Bool) -> Eq Pragma
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Pragma -> Pragma -> Bool
== :: Pragma -> Pragma -> Bool
$c/= :: Pragma -> Pragma -> Bool
/= :: Pragma -> Pragma -> Bool
Eq, Int -> Pragma -> ShowS
[Pragma] -> ShowS
Pragma -> String
(Int -> Pragma -> ShowS)
-> (Pragma -> String) -> ([Pragma] -> ShowS) -> Show Pragma
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Pragma -> ShowS
showsPrec :: Int -> Pragma -> ShowS
$cshow :: Pragma -> String
show :: Pragma -> String
$cshowList :: [Pragma] -> ShowS
showList :: [Pragma] -> ShowS
Show)

instance Parsec.Parsec Pragma where
  parsec :: forall (m :: * -> *). CabalParsing m => m Pragma
parsec = do
    m ()
forall (m :: * -> *). CharParsing m => m ()
CharParsing.spaces
    m String -> m ()
forall (f :: * -> *) a. Functor f => f a -> f ()
Monad.void (m String -> m ()) -> m String -> m ()
forall a b. (a -> b) -> a -> b
$ String -> m String
forall (m :: * -> *). CharParsing m => String -> m String
CharParsing.string String
"cabal-gild:"
    m ()
forall (m :: * -> *). CharParsing m => m ()
CharParsing.spaces
    m String -> m ()
forall (f :: * -> *) a. Functor f => f a -> f ()
Monad.void (m String -> m ()) -> m String -> m ()
forall a b. (a -> b) -> a -> b
$ String -> m String
forall (m :: * -> *). CharParsing m => String -> m String
CharParsing.string String
"discover"
    [Token']
arguments <-
      m [Token'] -> m [Token'] -> m [Token']
forall a. m a -> m a -> m a
forall (m :: * -> *) a. MonadPlus m => m a -> m a -> m a
Monad.mplus
        (m ()
forall (m :: * -> *). CharParsing m => m ()
CharParsing.skipSpaces1 m () -> m [Token'] -> m [Token']
forall a b. m a -> m b -> m b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> m Token' -> m () -> m [Token']
forall (m :: * -> *) a sep. Alternative m => m a -> m sep -> m [a]
CharParsing.sepBy m Token'
forall a (m :: * -> *). (Parsec a, CabalParsing m) => m a
forall (m :: * -> *). CabalParsing m => m Token'
Parsec.parsec m ()
forall (m :: * -> *). CharParsing m => m ()
CharParsing.skipSpaces1)
        ([] [Token'] -> m () -> m [Token']
forall a b. a -> m b -> m a
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ m ()
forall (m :: * -> *). CharParsing m => m ()
CharParsing.spaces)
    m ()
forall (m :: * -> *). Parsing m => m ()
CharParsing.eof
    Pragma -> m Pragma
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Pragma -> m Pragma)
-> ([String] -> Pragma) -> [String] -> m Pragma
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [String] -> Pragma
Discover ([String] -> m Pragma) -> [String] -> m Pragma
forall a b. (a -> b) -> a -> b
$ (Token' -> String) -> [Token'] -> [String]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Token' -> String
Newtypes.getToken' [Token']
arguments