-- |
-- Module: Staversion.Internal.Cabal
-- Description: functions dealing with .cabal files.
-- Maintainer: Toshio Ito <debug.ito@gmail.com>
--
-- __This is an internal module. End-users should not use it.__
module Staversion.Internal.Cabal
       ( loadCabalFile,
         Target(..),
         BuildDepends(..)
       ) where

import Control.Applicative ((<*), (*>), (<|>), (<*>), many, some)
import Control.Exception (IOException)
import qualified Control.Exception as Exception
import Control.Monad (void, mzero, forM)
import Data.Bifunctor (first)
import Data.Char (isAlpha, isDigit, toLower, isSpace)
import Data.List (intercalate, nub)
import Data.Monoid (mconcat)
import Data.Text (pack, Text)
import qualified Data.Text as T
import qualified Data.Text.IO as TIO

import qualified Staversion.Internal.Megaparsec as P
import Staversion.Internal.Query
  ( PackageName, ErrorMsg
  )

-- | Build target type.
data Target = TargetLibrary -- ^ the @library@ target.
            | TargetExecutable Text -- ^ the @executable NAME@ target.
            | TargetTestSuite Text -- ^ the @test-suite NAME@ target.
            | TargetBenchmark Text -- ^ the @benchmark NAME@ target.
            deriving (Int -> Target -> ShowS
[Target] -> ShowS
Target -> String
(Int -> Target -> ShowS)
-> (Target -> String) -> ([Target] -> ShowS) -> Show Target
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Target] -> ShowS
$cshowList :: [Target] -> ShowS
show :: Target -> String
$cshow :: Target -> String
showsPrec :: Int -> Target -> ShowS
$cshowsPrec :: Int -> Target -> ShowS
Show,Target -> Target -> Bool
(Target -> Target -> Bool)
-> (Target -> Target -> Bool) -> Eq Target
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Target -> Target -> Bool
$c/= :: Target -> Target -> Bool
== :: Target -> Target -> Bool
$c== :: Target -> Target -> Bool
Eq,Eq Target
Eq Target
-> (Target -> Target -> Ordering)
-> (Target -> Target -> Bool)
-> (Target -> Target -> Bool)
-> (Target -> Target -> Bool)
-> (Target -> Target -> Bool)
-> (Target -> Target -> Target)
-> (Target -> Target -> Target)
-> Ord Target
Target -> Target -> Bool
Target -> Target -> Ordering
Target -> Target -> Target
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Target -> Target -> Target
$cmin :: Target -> Target -> Target
max :: Target -> Target -> Target
$cmax :: Target -> Target -> Target
>= :: Target -> Target -> Bool
$c>= :: Target -> Target -> Bool
> :: Target -> Target -> Bool
$c> :: Target -> Target -> Bool
<= :: Target -> Target -> Bool
$c<= :: Target -> Target -> Bool
< :: Target -> Target -> Bool
$c< :: Target -> Target -> Bool
compare :: Target -> Target -> Ordering
$ccompare :: Target -> Target -> Ordering
$cp1Ord :: Eq Target
Ord)

-- | A block of @build-depends:@.
data BuildDepends =
  BuildDepends { BuildDepends -> Target
depsTarget :: Target,
                 BuildDepends -> [PackageName]
depsPackages :: [PackageName]
               } deriving (Int -> BuildDepends -> ShowS
[BuildDepends] -> ShowS
BuildDepends -> String
(Int -> BuildDepends -> ShowS)
-> (BuildDepends -> String)
-> ([BuildDepends] -> ShowS)
-> Show BuildDepends
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [BuildDepends] -> ShowS
$cshowList :: [BuildDepends] -> ShowS
show :: BuildDepends -> String
$cshow :: BuildDepends -> String
showsPrec :: Int -> BuildDepends -> ShowS
$cshowsPrec :: Int -> BuildDepends -> ShowS
Show,BuildDepends -> BuildDepends -> Bool
(BuildDepends -> BuildDepends -> Bool)
-> (BuildDepends -> BuildDepends -> Bool) -> Eq BuildDepends
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: BuildDepends -> BuildDepends -> Bool
$c/= :: BuildDepends -> BuildDepends -> Bool
== :: BuildDepends -> BuildDepends -> Bool
$c== :: BuildDepends -> BuildDepends -> Bool
Eq,Eq BuildDepends
Eq BuildDepends
-> (BuildDepends -> BuildDepends -> Ordering)
-> (BuildDepends -> BuildDepends -> Bool)
-> (BuildDepends -> BuildDepends -> Bool)
-> (BuildDepends -> BuildDepends -> Bool)
-> (BuildDepends -> BuildDepends -> Bool)
-> (BuildDepends -> BuildDepends -> BuildDepends)
-> (BuildDepends -> BuildDepends -> BuildDepends)
-> Ord BuildDepends
BuildDepends -> BuildDepends -> Bool
BuildDepends -> BuildDepends -> Ordering
BuildDepends -> BuildDepends -> BuildDepends
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: BuildDepends -> BuildDepends -> BuildDepends
$cmin :: BuildDepends -> BuildDepends -> BuildDepends
max :: BuildDepends -> BuildDepends -> BuildDepends
$cmax :: BuildDepends -> BuildDepends -> BuildDepends
>= :: BuildDepends -> BuildDepends -> Bool
$c>= :: BuildDepends -> BuildDepends -> Bool
> :: BuildDepends -> BuildDepends -> Bool
$c> :: BuildDepends -> BuildDepends -> Bool
<= :: BuildDepends -> BuildDepends -> Bool
$c<= :: BuildDepends -> BuildDepends -> Bool
< :: BuildDepends -> BuildDepends -> Bool
$c< :: BuildDepends -> BuildDepends -> Bool
compare :: BuildDepends -> BuildDepends -> Ordering
$ccompare :: BuildDepends -> BuildDepends -> Ordering
$cp1Ord :: Eq BuildDepends
Ord)

loadCabalFile :: FilePath -> IO (Either ErrorMsg [BuildDepends])
loadCabalFile :: String -> IO (Either String [BuildDepends])
loadCabalFile String
cabal_filepath = IO (Either String [BuildDepends])
-> IO (Either String [BuildDepends])
handleIOError (IO (Either String [BuildDepends])
 -> IO (Either String [BuildDepends]))
-> IO (Either String [BuildDepends])
-> IO (Either String [BuildDepends])
forall a b. (a -> b) -> a -> b
$ (ParseErrorBundle PackageName (ErrorFancy Void) -> String)
-> Either
     (ParseErrorBundle PackageName (ErrorFancy Void)) [BuildDepends]
-> Either String [BuildDepends]
forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first ParseErrorBundle PackageName (ErrorFancy Void) -> String
forall a. Show a => a -> String
show (Either
   (ParseErrorBundle PackageName (ErrorFancy Void)) [BuildDepends]
 -> Either String [BuildDepends])
-> (PackageName
    -> Either
         (ParseErrorBundle PackageName (ErrorFancy Void)) [BuildDepends])
-> PackageName
-> Either String [BuildDepends]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> PackageName
-> Either
     (ParseErrorBundle PackageName (ErrorFancy Void)) [BuildDepends]
parseContent (PackageName -> Either String [BuildDepends])
-> IO PackageName -> IO (Either String [BuildDepends])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> IO PackageName
readContent where
  readContent :: IO PackageName
readContent = String -> IO PackageName
TIO.readFile String
cabal_filepath
  parseContent :: PackageName
-> Either
     (ParseErrorBundle PackageName (ErrorFancy Void)) [BuildDepends]
parseContent = Parsec (ErrorFancy Void) PackageName [BuildDepends]
-> String
-> PackageName
-> Either
     (ParseErrorBundle PackageName (ErrorFancy Void)) [BuildDepends]
forall e s a.
Parsec e s a -> String -> s -> Either (ParseErrorBundle s e) a
P.runParser (Parsec (ErrorFancy Void) PackageName [BuildDepends]
cabalParser Parsec (ErrorFancy Void) PackageName [BuildDepends]
-> ParsecT (ErrorFancy Void) PackageName Identity ()
-> Parsec (ErrorFancy Void) PackageName [BuildDepends]
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* ParsecT (ErrorFancy Void) PackageName Identity ()
forall e s (m :: * -> *). MonadParsec e s m => m ()
P.eof) String
cabal_filepath
  handleIOError :: IO (Either String [BuildDepends])
-> IO (Either String [BuildDepends])
handleIOError = (IOException -> IO (Either String [BuildDepends]))
-> IO (Either String [BuildDepends])
-> IO (Either String [BuildDepends])
forall e a. Exception e => (e -> IO a) -> IO a -> IO a
Exception.handle IOException -> IO (Either String [BuildDepends])
h where
    h :: IOException -> IO (Either ErrorMsg [BuildDepends])
    h :: IOException -> IO (Either String [BuildDepends])
h = Either String [BuildDepends] -> IO (Either String [BuildDepends])
forall (m :: * -> *) a. Monad m => a -> m a
return (Either String [BuildDepends] -> IO (Either String [BuildDepends]))
-> (IOException -> Either String [BuildDepends])
-> IOException
-> IO (Either String [BuildDepends])
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Either String [BuildDepends]
forall a b. a -> Either a b
Left (String -> Either String [BuildDepends])
-> (IOException -> String)
-> IOException
-> Either String [BuildDepends]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. IOException -> String
forall a. Show a => a -> String
show

isLineSpace :: Char -> Bool
isLineSpace :: Char -> Bool
isLineSpace Char
' ' = Bool
True
isLineSpace Char
'\t' = Bool
True
isLineSpace Char
_ = Bool
False

isOpenBrace :: Char -> Bool
isOpenBrace :: Char -> Bool
isOpenBrace = (Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
'{')

isCloseBrace :: Char -> Bool
isCloseBrace :: Char -> Bool
isCloseBrace = (Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
'}')

isBrace :: Char -> Bool
isBrace :: Char -> Bool
isBrace Char
c = Char -> Bool
isOpenBrace Char
c Bool -> Bool -> Bool
|| Char -> Bool
isCloseBrace Char
c

lengthOf :: (Char -> Bool) -> P.Parser Int
lengthOf :: (Char -> Bool) -> Parser Int
lengthOf Char -> Bool
p = String -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length (String -> Int)
-> ParsecT (ErrorFancy Void) PackageName Identity String
-> Parser Int
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ParsecT (ErrorFancy Void) PackageName Identity Char
-> ParsecT (ErrorFancy Void) PackageName Identity String
forall (f :: * -> *) a. Alternative f => f a -> f [a]
many (ParsecT (ErrorFancy Void) PackageName Identity Char
 -> ParsecT (ErrorFancy Void) PackageName Identity String)
-> ParsecT (ErrorFancy Void) PackageName Identity Char
-> ParsecT (ErrorFancy Void) PackageName Identity String
forall a b. (a -> b) -> a -> b
$ (Token PackageName -> Bool)
-> ParsecT
     (ErrorFancy Void) PackageName Identity (Token PackageName)
forall e s (m :: * -> *).
MonadParsec e s m =>
(Token s -> Bool) -> m (Token s)
P.satisfy Char -> Bool
Token PackageName -> Bool
p)

indent :: P.Parser Int
indent :: Parser Int
indent = (Char -> Bool) -> Parser Int
lengthOf Char -> Bool
isLineSpace

finishLine :: P.Parser ()
finishLine :: ParsecT (ErrorFancy Void) PackageName Identity ()
finishLine = ParsecT (ErrorFancy Void) PackageName Identity ()
forall e s (m :: * -> *). MonadParsec e s m => m ()
P.eof ParsecT (ErrorFancy Void) PackageName Identity ()
-> ParsecT (ErrorFancy Void) PackageName Identity ()
-> ParsecT (ErrorFancy Void) PackageName Identity ()
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ParsecT (ErrorFancy Void) PackageName Identity PackageName
-> ParsecT (ErrorFancy Void) PackageName Identity ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void ParsecT (ErrorFancy Void) PackageName Identity PackageName
forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m (Tokens s)
P.eol

emptyLine :: P.Parser ()
emptyLine :: ParsecT (ErrorFancy Void) PackageName Identity ()
emptyLine = Parser Int
indent Parser Int
-> ParsecT (ErrorFancy Void) PackageName Identity ()
-> ParsecT (ErrorFancy Void) PackageName Identity ()
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> (ParsecT (ErrorFancy Void) PackageName Identity ()
comment_line ParsecT (ErrorFancy Void) PackageName Identity ()
-> ParsecT (ErrorFancy Void) PackageName Identity ()
-> ParsecT (ErrorFancy Void) PackageName Identity ()
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ParsecT (ErrorFancy Void) PackageName Identity PackageName
-> ParsecT (ErrorFancy Void) PackageName Identity ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void ParsecT (ErrorFancy Void) PackageName Identity PackageName
forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m (Tokens s)
P.eol) where
  comment_line :: ParsecT (ErrorFancy Void) PackageName Identity ()
comment_line = (ParsecT (ErrorFancy Void) PackageName Identity String
-> ParsecT (ErrorFancy Void) PackageName Identity String
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
P.try (ParsecT (ErrorFancy Void) PackageName Identity String
 -> ParsecT (ErrorFancy Void) PackageName Identity String)
-> ParsecT (ErrorFancy Void) PackageName Identity String
-> ParsecT (ErrorFancy Void) PackageName Identity String
forall a b. (a -> b) -> a -> b
$ String -> ParsecT (ErrorFancy Void) PackageName Identity String
P.string String
"--") ParsecT (ErrorFancy Void) PackageName Identity String
-> ParsecT (ErrorFancy Void) PackageName Identity String
-> ParsecT (ErrorFancy Void) PackageName Identity String
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> ParsecT (ErrorFancy Void) PackageName Identity Char
-> ParsecT (ErrorFancy Void) PackageName Identity PackageName
-> ParsecT (ErrorFancy Void) PackageName Identity String
forall (m :: * -> *) a end. MonadPlus m => m a -> m end -> m [a]
P.manyTill ParsecT (ErrorFancy Void) PackageName Identity Char
P.anyChar ParsecT (ErrorFancy Void) PackageName Identity PackageName
forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m (Tokens s)
P.eol ParsecT (ErrorFancy Void) PackageName Identity String
-> ParsecT (ErrorFancy Void) PackageName Identity ()
-> ParsecT (ErrorFancy Void) PackageName Identity ()
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> () -> ParsecT (ErrorFancy Void) PackageName Identity ()
forall (f :: * -> *) a. Applicative f => a -> f a
pure ()

blockHeadLine :: P.Parser Target
blockHeadLine :: Parser Target
blockHeadLine = Parser Target
target Parser Target
-> ParsecT (ErrorFancy Void) PackageName Identity String
-> Parser Target
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* ParsecT (ErrorFancy Void) PackageName Identity String
trail Parser Target
-> ParsecT (ErrorFancy Void) PackageName Identity ()
-> Parser Target
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* ParsecT (ErrorFancy Void) PackageName Identity ()
finishLine where
  trail :: ParsecT (ErrorFancy Void) PackageName Identity String
trail = ParsecT (ErrorFancy Void) PackageName Identity Char
-> ParsecT (ErrorFancy Void) PackageName Identity String
forall (f :: * -> *) a. Alternative f => f a -> f [a]
many (ParsecT (ErrorFancy Void) PackageName Identity Char
 -> ParsecT (ErrorFancy Void) PackageName Identity String)
-> ParsecT (ErrorFancy Void) PackageName Identity Char
-> ParsecT (ErrorFancy Void) PackageName Identity String
forall a b. (a -> b) -> a -> b
$ (Token PackageName -> Bool)
-> ParsecT
     (ErrorFancy Void) PackageName Identity (Token PackageName)
forall e s (m :: * -> *).
MonadParsec e s m =>
(Token s -> Bool) -> m (Token s)
P.satisfy ((Token PackageName -> Bool)
 -> ParsecT
      (ErrorFancy Void) PackageName Identity (Token PackageName))
-> (Token PackageName -> Bool)
-> ParsecT
     (ErrorFancy Void) PackageName Identity (Token PackageName)
forall a b. (a -> b) -> a -> b
$ \Token PackageName
c -> Char -> Bool
isLineSpace Char
Token PackageName
c Bool -> Bool -> Bool
|| Char -> Bool
isOpenBrace Char
Token PackageName
c
  target :: Parser Target
target = Parser Target
target_lib Parser Target -> Parser Target -> Parser Target
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser Target
target_exe Parser Target -> Parser Target -> Parser Target
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser Target
target_test Parser Target -> Parser Target -> Parser Target
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser Target
target_bench
  target_lib :: Parser Target
target_lib = ParsecT (ErrorFancy Void) PackageName Identity String
-> ParsecT (ErrorFancy Void) PackageName Identity String
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
P.try (String -> ParsecT (ErrorFancy Void) PackageName Identity String
P.string' String
"library") ParsecT (ErrorFancy Void) PackageName Identity String
-> Parser Target -> Parser Target
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Target -> Parser Target
forall (f :: * -> *) a. Applicative f => a -> f a
pure Target
TargetLibrary
  target_exe :: Parser Target
target_exe = PackageName -> Target
TargetExecutable (PackageName -> Target)
-> ParsecT (ErrorFancy Void) PackageName Identity PackageName
-> Parser Target
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> String
-> ParsecT (ErrorFancy Void) PackageName Identity PackageName
targetNamed String
"executable"
  target_test :: Parser Target
target_test = PackageName -> Target
TargetTestSuite (PackageName -> Target)
-> ParsecT (ErrorFancy Void) PackageName Identity PackageName
-> Parser Target
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> String
-> ParsecT (ErrorFancy Void) PackageName Identity PackageName
targetNamed String
"test-suite"
  target_bench :: Parser Target
target_bench = PackageName -> Target
TargetBenchmark (PackageName -> Target)
-> ParsecT (ErrorFancy Void) PackageName Identity PackageName
-> Parser Target
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> String
-> ParsecT (ErrorFancy Void) PackageName Identity PackageName
targetNamed String
"benchmark"
  targetNamed :: String -> P.Parser Text
  targetNamed :: String
-> ParsecT (ErrorFancy Void) PackageName Identity PackageName
targetNamed String
target_type = ParsecT (ErrorFancy Void) PackageName Identity String
-> ParsecT (ErrorFancy Void) PackageName Identity String
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
P.try (String -> ParsecT (ErrorFancy Void) PackageName Identity String
P.string' String
target_type)
                            ParsecT (ErrorFancy Void) PackageName Identity String
-> ParsecT (ErrorFancy Void) PackageName Identity String
-> ParsecT (ErrorFancy Void) PackageName Identity String
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> (ParsecT (ErrorFancy Void) PackageName Identity Char
-> ParsecT (ErrorFancy Void) PackageName Identity String
forall (f :: * -> *) a. Alternative f => f a -> f [a]
some (ParsecT (ErrorFancy Void) PackageName Identity Char
 -> ParsecT (ErrorFancy Void) PackageName Identity String)
-> ParsecT (ErrorFancy Void) PackageName Identity Char
-> ParsecT (ErrorFancy Void) PackageName Identity String
forall a b. (a -> b) -> a -> b
$ (Token PackageName -> Bool)
-> ParsecT
     (ErrorFancy Void) PackageName Identity (Token PackageName)
forall e s (m :: * -> *).
MonadParsec e s m =>
(Token s -> Bool) -> m (Token s)
P.satisfy Char -> Bool
Token PackageName -> Bool
isLineSpace)
                            ParsecT (ErrorFancy Void) PackageName Identity String
-> ParsecT (ErrorFancy Void) PackageName Identity PackageName
-> ParsecT (ErrorFancy Void) PackageName Identity PackageName
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> ((String -> PackageName)
-> ParsecT (ErrorFancy Void) PackageName Identity String
-> ParsecT (ErrorFancy Void) PackageName Identity PackageName
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap String -> PackageName
pack (ParsecT (ErrorFancy Void) PackageName Identity String
 -> ParsecT (ErrorFancy Void) PackageName Identity PackageName)
-> ParsecT (ErrorFancy Void) PackageName Identity String
-> ParsecT (ErrorFancy Void) PackageName Identity PackageName
forall a b. (a -> b) -> a -> b
$ ParsecT (ErrorFancy Void) PackageName Identity Char
-> ParsecT (ErrorFancy Void) PackageName Identity String
forall (f :: * -> *) a. Alternative f => f a -> f [a]
some (ParsecT (ErrorFancy Void) PackageName Identity Char
 -> ParsecT (ErrorFancy Void) PackageName Identity String)
-> ParsecT (ErrorFancy Void) PackageName Identity Char
-> ParsecT (ErrorFancy Void) PackageName Identity String
forall a b. (a -> b) -> a -> b
$ (Token PackageName -> Bool)
-> ParsecT
     (ErrorFancy Void) PackageName Identity (Token PackageName)
forall e s (m :: * -> *).
MonadParsec e s m =>
(Token s -> Bool) -> m (Token s)
P.satisfy (Bool -> Bool
not (Bool -> Bool) -> (Char -> Bool) -> Char -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> Bool
isSpace))

fieldStart :: Maybe String -- ^ expected field name. If Nothing, it just don't care.
           -> P.Parser (String, Int) -- ^ (lower-case field name, indent level)
fieldStart :: Maybe String -> Parser (String, Int)
fieldStart Maybe String
mexp_name = do
  Int
level <- Parser Int
indent
  String
name <- ParsecT (ErrorFancy Void) PackageName Identity String
nameParser ParsecT (ErrorFancy Void) PackageName Identity String
-> Parser Int
-> ParsecT (ErrorFancy Void) PackageName Identity String
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Parser Int
indent ParsecT (ErrorFancy Void) PackageName Identity String
-> ParsecT (ErrorFancy Void) PackageName Identity Char
-> ParsecT (ErrorFancy Void) PackageName Identity String
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Token PackageName
-> ParsecT
     (ErrorFancy Void) PackageName Identity (Token PackageName)
forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
Token s -> m (Token s)
P.char Char
Token PackageName
':'
  (String, Int) -> Parser (String, Int)
forall (m :: * -> *) a. Monad m => a -> m a
return ((Char -> Char) -> ShowS
forall a b. (a -> b) -> [a] -> [b]
map Char -> Char
toLower String
name, Int
level)
  where
    nameParser :: ParsecT (ErrorFancy Void) PackageName Identity String
nameParser = case Maybe String
mexp_name of
      Maybe String
Nothing -> ParsecT (ErrorFancy Void) PackageName Identity Char
-> ParsecT (ErrorFancy Void) PackageName Identity String
forall (f :: * -> *) a. Alternative f => f a -> f [a]
some (ParsecT (ErrorFancy Void) PackageName Identity Char
 -> ParsecT (ErrorFancy Void) PackageName Identity String)
-> ParsecT (ErrorFancy Void) PackageName Identity Char
-> ParsecT (ErrorFancy Void) PackageName Identity String
forall a b. (a -> b) -> a -> b
$ (Token PackageName -> Bool)
-> ParsecT
     (ErrorFancy Void) PackageName Identity (Token PackageName)
forall e s (m :: * -> *).
MonadParsec e s m =>
(Token s -> Bool) -> m (Token s)
P.satisfy ((Token PackageName -> Bool)
 -> ParsecT
      (ErrorFancy Void) PackageName Identity (Token PackageName))
-> (Token PackageName -> Bool)
-> ParsecT
     (ErrorFancy Void) PackageName Identity (Token PackageName)
forall a b. (a -> b) -> a -> b
$ \Token PackageName
c -> Bool -> Bool
not (Char -> Bool
isLineSpace Char
Token PackageName
c Bool -> Bool -> Bool
|| Char
Token PackageName
c Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
':')
      Just String
exp_name -> String -> ParsecT (ErrorFancy Void) PackageName Identity String
P.string' String
exp_name

fieldBlock :: P.Parser (String, Text) -- ^ (lower-case field name, block content)
fieldBlock :: Parser (String, PackageName)
fieldBlock = Parser (String, PackageName)
impl where
  impl :: Parser (String, PackageName)
impl = do
    (String
field_name, Int
level) <- Parser (String, Int) -> Parser (String, Int)
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
P.try (Parser (String, Int) -> Parser (String, Int))
-> Parser (String, Int) -> Parser (String, Int)
forall a b. (a -> b) -> a -> b
$ do
      [()]
_ <- ParsecT (ErrorFancy Void) PackageName Identity ()
-> ParsecT (ErrorFancy Void) PackageName Identity [()]
forall (f :: * -> *) a. Alternative f => f a -> f [a]
many (ParsecT (ErrorFancy Void) PackageName Identity ()
 -> ParsecT (ErrorFancy Void) PackageName Identity [()])
-> ParsecT (ErrorFancy Void) PackageName Identity ()
-> ParsecT (ErrorFancy Void) PackageName Identity [()]
forall a b. (a -> b) -> a -> b
$ (ParsecT (ErrorFancy Void) PackageName Identity ()
-> ParsecT (ErrorFancy Void) PackageName Identity ()
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
P.try ParsecT (ErrorFancy Void) PackageName Identity ()
emptyLine ParsecT (ErrorFancy Void) PackageName Identity ()
-> ParsecT (ErrorFancy Void) PackageName Identity ()
-> ParsecT (ErrorFancy Void) PackageName Identity ()
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ParsecT (ErrorFancy Void) PackageName Identity ()
-> ParsecT (ErrorFancy Void) PackageName Identity ()
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
P.try ParsecT (ErrorFancy Void) PackageName Identity ()
conditionalLine ParsecT (ErrorFancy Void) PackageName Identity ()
-> ParsecT (ErrorFancy Void) PackageName Identity ()
-> ParsecT (ErrorFancy Void) PackageName Identity ()
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ParsecT (ErrorFancy Void) PackageName Identity ()
-> ParsecT (ErrorFancy Void) PackageName Identity ()
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
P.try ParsecT (ErrorFancy Void) PackageName Identity ()
bracesOnlyLine)
      Maybe String -> Parser (String, Int)
fieldStart Maybe String
forall a. Maybe a
Nothing
    String
field_trail <- ParsecT (ErrorFancy Void) PackageName Identity Char
-> ParsecT (ErrorFancy Void) PackageName Identity ()
-> ParsecT (ErrorFancy Void) PackageName Identity String
forall (m :: * -> *) a end. MonadPlus m => m a -> m end -> m [a]
P.manyTill ParsecT (ErrorFancy Void) PackageName Identity Char
P.anyChar ParsecT (ErrorFancy Void) PackageName Identity ()
finishLine
    [String]
rest <- Int -> ParsecT (ErrorFancy Void) PackageName Identity [String]
remainingLines Int
level
    let text_block :: PackageName
text_block = PackageName -> [PackageName] -> PackageName
T.intercalate PackageName
"\n" ([PackageName] -> PackageName) -> [PackageName] -> PackageName
forall a b. (a -> b) -> a -> b
$ (String -> PackageName) -> [String] -> [PackageName]
forall a b. (a -> b) -> [a] -> [b]
map String -> PackageName
pack (String
field_trail String -> [String] -> [String]
forall a. a -> [a] -> [a]
: [String]
rest)
    (String, PackageName) -> Parser (String, PackageName)
forall (m :: * -> *) a. Monad m => a -> m a
return (String
field_name, PackageName
text_block)
  remainingLines :: Int -> ParsecT (ErrorFancy Void) PackageName Identity [String]
remainingLines Int
field_indent_level = [String] -> [String]
forall a. [a] -> [a]
reverse ([String] -> [String])
-> ParsecT (ErrorFancy Void) PackageName Identity [String]
-> ParsecT (ErrorFancy Void) PackageName Identity [String]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [String] -> ParsecT (ErrorFancy Void) PackageName Identity [String]
go [] where
    go :: [String] -> ParsecT (ErrorFancy Void) PackageName Identity [String]
go [String]
cur_lines = (ParsecT (ErrorFancy Void) PackageName Identity ()
forall e s (m :: * -> *). MonadParsec e s m => m ()
P.eof ParsecT (ErrorFancy Void) PackageName Identity ()
-> ParsecT (ErrorFancy Void) PackageName Identity [String]
-> ParsecT (ErrorFancy Void) PackageName Identity [String]
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> [String] -> ParsecT (ErrorFancy Void) PackageName Identity [String]
forall (f :: * -> *) a. Applicative f => a -> f a
pure [String]
cur_lines) ParsecT (ErrorFancy Void) PackageName Identity [String]
-> ParsecT (ErrorFancy Void) PackageName Identity [String]
-> ParsecT (ErrorFancy Void) PackageName Identity [String]
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> [String] -> ParsecT (ErrorFancy Void) PackageName Identity [String]
foundSomething [String]
cur_lines
    foundSomething :: [String] -> ParsecT (ErrorFancy Void) PackageName Identity [String]
foundSomething [String]
cur_lines = do
      ParsecT (ErrorFancy Void) PackageName Identity [()]
-> ParsecT (ErrorFancy Void) PackageName Identity ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (ParsecT (ErrorFancy Void) PackageName Identity [()]
 -> ParsecT (ErrorFancy Void) PackageName Identity ())
-> ParsecT (ErrorFancy Void) PackageName Identity [()]
-> ParsecT (ErrorFancy Void) PackageName Identity ()
forall a b. (a -> b) -> a -> b
$ ParsecT (ErrorFancy Void) PackageName Identity ()
-> ParsecT (ErrorFancy Void) PackageName Identity [()]
forall (f :: * -> *) a. Alternative f => f a -> f [a]
many (ParsecT (ErrorFancy Void) PackageName Identity ()
 -> ParsecT (ErrorFancy Void) PackageName Identity [()])
-> ParsecT (ErrorFancy Void) PackageName Identity ()
-> ParsecT (ErrorFancy Void) PackageName Identity [()]
forall a b. (a -> b) -> a -> b
$ ParsecT (ErrorFancy Void) PackageName Identity ()
-> ParsecT (ErrorFancy Void) PackageName Identity ()
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
P.try ParsecT (ErrorFancy Void) PackageName Identity ()
emptyLine
      Int
this_level <- Parser Int -> Parser Int
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
P.lookAhead Parser Int
indent
      if Int
this_level Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<= Int
field_indent_level
        then [String] -> ParsecT (ErrorFancy Void) PackageName Identity [String]
forall (f :: * -> *) a. Applicative f => a -> f a
pure [String]
cur_lines
        else do
        Int
_ <- Parser Int
indent
        String
this_line <- ParsecT (ErrorFancy Void) PackageName Identity Char
-> ParsecT (ErrorFancy Void) PackageName Identity ()
-> ParsecT (ErrorFancy Void) PackageName Identity String
forall (m :: * -> *) a end. MonadPlus m => m a -> m end -> m [a]
P.manyTill ParsecT (ErrorFancy Void) PackageName Identity Char
P.anyChar ParsecT (ErrorFancy Void) PackageName Identity ()
finishLine
        [String] -> ParsecT (ErrorFancy Void) PackageName Identity [String]
go (String
this_line String -> [String] -> [String]
forall a. a -> [a] -> [a]
: [String]
cur_lines)
  bracesOnlyLine :: ParsecT (ErrorFancy Void) PackageName Identity ()
bracesOnlyLine = Parser Int
indent Parser Int
-> ParsecT (ErrorFancy Void) PackageName Identity [Int]
-> ParsecT (ErrorFancy Void) PackageName Identity [Int]
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Parser Int -> ParsecT (ErrorFancy Void) PackageName Identity [Int]
forall (f :: * -> *) a. Alternative f => f a -> f [a]
some Parser Int
braceAndSpace ParsecT (ErrorFancy Void) PackageName Identity [Int]
-> ParsecT (ErrorFancy Void) PackageName Identity ()
-> ParsecT (ErrorFancy Void) PackageName Identity ()
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> ParsecT (ErrorFancy Void) PackageName Identity ()
finishLine
  braceAndSpace :: Parser Int
braceAndSpace = (Token PackageName -> Bool)
-> ParsecT
     (ErrorFancy Void) PackageName Identity (Token PackageName)
forall e s (m :: * -> *).
MonadParsec e s m =>
(Token s -> Bool) -> m (Token s)
P.satisfy Char -> Bool
Token PackageName -> Bool
isBrace ParsecT (ErrorFancy Void) PackageName Identity Char
-> Parser Int -> Parser Int
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Parser Int
indent

buildDependsLine :: P.Parser [PackageName]
buildDependsLine :: Parser [PackageName]
buildDependsLine = ParsecT (ErrorFancy Void) PackageName Identity ()
forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m ()
P.space ParsecT (ErrorFancy Void) PackageName Identity ()
-> Parser [PackageName] -> Parser [PackageName]
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> (ParsecT (ErrorFancy Void) PackageName Identity PackageName
pname ParsecT (ErrorFancy Void) PackageName Identity PackageName
-> ParsecT (ErrorFancy Void) PackageName Identity ()
-> Parser [PackageName]
forall (m :: * -> *) a end. MonadPlus m => m a -> m end -> m [a]
`P.endBy` ParsecT (ErrorFancy Void) PackageName Identity ()
ignored) where
  pname :: ParsecT (ErrorFancy Void) PackageName Identity PackageName
pname = String -> PackageName
pack (String -> PackageName)
-> ParsecT (ErrorFancy Void) PackageName Identity String
-> ParsecT (ErrorFancy Void) PackageName Identity PackageName
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ParsecT (ErrorFancy Void) PackageName Identity Char
-> ParsecT (ErrorFancy Void) PackageName Identity String
forall (f :: * -> *) a. Alternative f => f a -> f [a]
some (ParsecT (ErrorFancy Void) PackageName Identity Char
 -> ParsecT (ErrorFancy Void) PackageName Identity String)
-> ParsecT (ErrorFancy Void) PackageName Identity Char
-> ParsecT (ErrorFancy Void) PackageName Identity String
forall a b. (a -> b) -> a -> b
$ (Token PackageName -> Bool)
-> ParsecT
     (ErrorFancy Void) PackageName Identity (Token PackageName)
forall e s (m :: * -> *).
MonadParsec e s m =>
(Token s -> Bool) -> m (Token s)
P.satisfy Char -> Bool
Token PackageName -> Bool
allowedChar)
  allowedChar :: Char -> Bool
allowedChar Char
'-' = Bool
True
  allowedChar Char
'_' = Bool
True
  allowedChar Char
c = Char -> Bool
isAlpha Char
c Bool -> Bool -> Bool
|| Char -> Bool
isDigit Char
c
  ignored :: ParsecT (ErrorFancy Void) PackageName Identity ()
ignored = ParsecT (ErrorFancy Void) PackageName Identity Char
-> ParsecT (ErrorFancy Void) PackageName Identity ()
-> ParsecT (ErrorFancy Void) PackageName Identity String
forall (m :: * -> *) a end. MonadPlus m => m a -> m end -> m [a]
P.manyTill ParsecT (ErrorFancy Void) PackageName Identity Char
P.anyChar ParsecT (ErrorFancy Void) PackageName Identity ()
finishItem ParsecT (ErrorFancy Void) PackageName Identity String
-> ParsecT (ErrorFancy Void) PackageName Identity ()
-> ParsecT (ErrorFancy Void) PackageName Identity ()
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> ParsecT (ErrorFancy Void) PackageName Identity ()
forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m ()
P.space
  finishItem :: ParsecT (ErrorFancy Void) PackageName Identity ()
finishItem = ParsecT (ErrorFancy Void) PackageName Identity ()
forall e s (m :: * -> *). MonadParsec e s m => m ()
P.eof ParsecT (ErrorFancy Void) PackageName Identity ()
-> ParsecT (ErrorFancy Void) PackageName Identity ()
-> ParsecT (ErrorFancy Void) PackageName Identity ()
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (ParsecT (ErrorFancy Void) PackageName Identity Char
-> ParsecT (ErrorFancy Void) PackageName Identity ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (ParsecT (ErrorFancy Void) PackageName Identity Char
 -> ParsecT (ErrorFancy Void) PackageName Identity ())
-> ParsecT (ErrorFancy Void) PackageName Identity Char
-> ParsecT (ErrorFancy Void) PackageName Identity ()
forall a b. (a -> b) -> a -> b
$ Token PackageName
-> ParsecT
     (ErrorFancy Void) PackageName Identity (Token PackageName)
forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
Token s -> m (Token s)
P.char Char
Token PackageName
',')

conditionalLine :: P.Parser ()
conditionalLine :: ParsecT (ErrorFancy Void) PackageName Identity ()
conditionalLine = ParsecT (ErrorFancy Void) PackageName Identity String
-> ParsecT (ErrorFancy Void) PackageName Identity ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (ParsecT (ErrorFancy Void) PackageName Identity String
 -> ParsecT (ErrorFancy Void) PackageName Identity ())
-> ParsecT (ErrorFancy Void) PackageName Identity String
-> ParsecT (ErrorFancy Void) PackageName Identity ()
forall a b. (a -> b) -> a -> b
$ ParsecT (ErrorFancy Void) PackageName Identity String
leader ParsecT (ErrorFancy Void) PackageName Identity String
-> ParsecT (ErrorFancy Void) PackageName Identity ()
-> ParsecT (ErrorFancy Void) PackageName Identity ()
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> (String -> ParsecT (ErrorFancy Void) PackageName Identity ()
term String
"if" ParsecT (ErrorFancy Void) PackageName Identity ()
-> ParsecT (ErrorFancy Void) PackageName Identity ()
-> ParsecT (ErrorFancy Void) PackageName Identity ()
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> String -> ParsecT (ErrorFancy Void) PackageName Identity ()
term String
"else") ParsecT (ErrorFancy Void) PackageName Identity ()
-> ParsecT (ErrorFancy Void) PackageName Identity String
-> ParsecT (ErrorFancy Void) PackageName Identity String
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> ParsecT (ErrorFancy Void) PackageName Identity Char
-> ParsecT (ErrorFancy Void) PackageName Identity ()
-> ParsecT (ErrorFancy Void) PackageName Identity String
forall (m :: * -> *) a end. MonadPlus m => m a -> m end -> m [a]
P.manyTill ParsecT (ErrorFancy Void) PackageName Identity Char
P.anyChar ParsecT (ErrorFancy Void) PackageName Identity ()
finishLine where
  leader :: ParsecT (ErrorFancy Void) PackageName Identity String
leader = ParsecT (ErrorFancy Void) PackageName Identity Char
-> ParsecT (ErrorFancy Void) PackageName Identity String
forall (f :: * -> *) a. Alternative f => f a -> f [a]
many (ParsecT (ErrorFancy Void) PackageName Identity Char
 -> ParsecT (ErrorFancy Void) PackageName Identity String)
-> ParsecT (ErrorFancy Void) PackageName Identity Char
-> ParsecT (ErrorFancy Void) PackageName Identity String
forall a b. (a -> b) -> a -> b
$ (Token PackageName -> Bool)
-> ParsecT
     (ErrorFancy Void) PackageName Identity (Token PackageName)
forall e s (m :: * -> *).
MonadParsec e s m =>
(Token s -> Bool) -> m (Token s)
P.satisfy ((Token PackageName -> Bool)
 -> ParsecT
      (ErrorFancy Void) PackageName Identity (Token PackageName))
-> (Token PackageName -> Bool)
-> ParsecT
     (ErrorFancy Void) PackageName Identity (Token PackageName)
forall a b. (a -> b) -> a -> b
$ \Token PackageName
c -> Char -> Bool
isLineSpace Char
Token PackageName
c Bool -> Bool -> Bool
|| Char -> Bool
isCloseBrace Char
Token PackageName
c
  term :: String -> P.Parser ()
  term :: String -> ParsecT (ErrorFancy Void) PackageName Identity ()
term String
t = ParsecT (ErrorFancy Void) PackageName Identity ()
-> ParsecT (ErrorFancy Void) PackageName Identity ()
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
P.try (String -> ParsecT (ErrorFancy Void) PackageName Identity String
P.string' String
t ParsecT (ErrorFancy Void) PackageName Identity String
-> ParsecT (ErrorFancy Void) PackageName Identity ()
-> ParsecT (ErrorFancy Void) PackageName Identity ()
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> ParsecT (ErrorFancy Void) PackageName Identity ()
-> ParsecT (ErrorFancy Void) PackageName Identity ()
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
P.lookAhead ParsecT (ErrorFancy Void) PackageName Identity ()
term_sep)
  term_sep :: ParsecT (ErrorFancy Void) PackageName Identity ()
term_sep = ParsecT (ErrorFancy Void) PackageName Identity Char
-> ParsecT (ErrorFancy Void) PackageName Identity ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (ParsecT (ErrorFancy Void) PackageName Identity Char
 -> ParsecT (ErrorFancy Void) PackageName Identity ())
-> ParsecT (ErrorFancy Void) PackageName Identity Char
-> ParsecT (ErrorFancy Void) PackageName Identity ()
forall a b. (a -> b) -> a -> b
$ (Token PackageName -> Bool)
-> ParsecT
     (ErrorFancy Void) PackageName Identity (Token PackageName)
forall e s (m :: * -> *).
MonadParsec e s m =>
(Token s -> Bool) -> m (Token s)
P.satisfy ((Token PackageName -> Bool)
 -> ParsecT
      (ErrorFancy Void) PackageName Identity (Token PackageName))
-> (Token PackageName -> Bool)
-> ParsecT
     (ErrorFancy Void) PackageName Identity (Token PackageName)
forall a b. (a -> b) -> a -> b
$ \Token PackageName
c -> Char -> Bool
isSpace Char
Token PackageName
c Bool -> Bool -> Bool
|| Char -> Bool
isBrace Char
Token PackageName
c

targetBlock :: P.Parser BuildDepends
targetBlock :: Parser BuildDepends
targetBlock = do
  Target
target <- Parser Target -> Parser Target
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
P.try Parser Target
blockHeadLine
  [(String, PackageName)]
fields <- Parser (String, PackageName)
-> ParsecT
     (ErrorFancy Void) PackageName Identity [(String, PackageName)]
forall (f :: * -> *) a. Alternative f => f a -> f [a]
some Parser (String, PackageName)
fieldBlock
  let build_deps_blocks :: [PackageName]
build_deps_blocks = ((String, PackageName) -> PackageName)
-> [(String, PackageName)] -> [PackageName]
forall a b. (a -> b) -> [a] -> [b]
map (String, PackageName) -> PackageName
forall a b. (a, b) -> b
snd ([(String, PackageName)] -> [PackageName])
-> [(String, PackageName)] -> [PackageName]
forall a b. (a -> b) -> a -> b
$ ((String, PackageName) -> Bool)
-> [(String, PackageName)] -> [(String, PackageName)]
forall a. (a -> Bool) -> [a] -> [a]
filter ((String
"build-depends" String -> String -> Bool
forall a. Eq a => a -> a -> Bool
==) (String -> Bool)
-> ((String, PackageName) -> String)
-> (String, PackageName)
-> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (String, PackageName) -> String
forall a b. (a, b) -> a
fst) ([(String, PackageName)] -> [(String, PackageName)])
-> [(String, PackageName)] -> [(String, PackageName)]
forall a b. (a -> b) -> a -> b
$ [(String, PackageName)]
fields
  [PackageName]
packages <- ([[PackageName]] -> [PackageName])
-> ParsecT (ErrorFancy Void) PackageName Identity [[PackageName]]
-> Parser [PackageName]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ([PackageName] -> [PackageName]
forall a. Eq a => [a] -> [a]
nub ([PackageName] -> [PackageName])
-> ([[PackageName]] -> [PackageName])
-> [[PackageName]]
-> [PackageName]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [[PackageName]] -> [PackageName]
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat) (ParsecT (ErrorFancy Void) PackageName Identity [[PackageName]]
 -> Parser [PackageName])
-> ParsecT (ErrorFancy Void) PackageName Identity [[PackageName]]
-> Parser [PackageName]
forall a b. (a -> b) -> a -> b
$ [PackageName]
-> (PackageName -> Parser [PackageName])
-> ParsecT (ErrorFancy Void) PackageName Identity [[PackageName]]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
t a -> (a -> m b) -> m (t b)
forM [PackageName]
build_deps_blocks ((PackageName -> Parser [PackageName])
 -> ParsecT (ErrorFancy Void) PackageName Identity [[PackageName]])
-> (PackageName -> Parser [PackageName])
-> ParsecT (ErrorFancy Void) PackageName Identity [[PackageName]]
forall a b. (a -> b) -> a -> b
$ \PackageName
block -> do
    (ParseErrorBundle PackageName (ErrorFancy Void)
 -> Parser [PackageName])
-> ([PackageName] -> Parser [PackageName])
-> Either
     (ParseErrorBundle PackageName (ErrorFancy Void)) [PackageName]
-> Parser [PackageName]
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either (String -> Parser [PackageName]
forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String -> Parser [PackageName])
-> (ParseErrorBundle PackageName (ErrorFancy Void) -> String)
-> ParseErrorBundle PackageName (ErrorFancy Void)
-> Parser [PackageName]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ParseErrorBundle PackageName (ErrorFancy Void) -> String
forall a. Show a => a -> String
show) [PackageName] -> Parser [PackageName]
forall (m :: * -> *) a. Monad m => a -> m a
return (Either
   (ParseErrorBundle PackageName (ErrorFancy Void)) [PackageName]
 -> Parser [PackageName])
-> Either
     (ParseErrorBundle PackageName (ErrorFancy Void)) [PackageName]
-> Parser [PackageName]
forall a b. (a -> b) -> a -> b
$ Parser [PackageName]
-> String
-> PackageName
-> Either
     (ParseErrorBundle PackageName (ErrorFancy Void)) [PackageName]
forall e s a.
Parsec e s a -> String -> s -> Either (ParseErrorBundle s e) a
P.runParser (Parser [PackageName]
buildDependsLine Parser [PackageName]
-> ParsecT (ErrorFancy Void) PackageName Identity ()
-> Parser [PackageName]
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* ParsecT (ErrorFancy Void) PackageName Identity ()
forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m ()
P.space Parser [PackageName]
-> ParsecT (ErrorFancy Void) PackageName Identity ()
-> Parser [PackageName]
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* ParsecT (ErrorFancy Void) PackageName Identity ()
forall e s (m :: * -> *). MonadParsec e s m => m ()
P.eof) String
"build-depends" PackageName
block
  BuildDepends -> Parser BuildDepends
forall (m :: * -> *) a. Monad m => a -> m a
return (BuildDepends -> Parser BuildDepends)
-> BuildDepends -> Parser BuildDepends
forall a b. (a -> b) -> a -> b
$ BuildDepends :: Target -> [PackageName] -> BuildDepends
BuildDepends { depsTarget :: Target
depsTarget = Target
target,
                          depsPackages :: [PackageName]
depsPackages = [PackageName]
packages
                        }

cabalParser :: P.Parser [BuildDepends]
cabalParser :: Parsec (ErrorFancy Void) PackageName [BuildDepends]
cabalParser = [BuildDepends] -> [BuildDepends]
forall a. [a] -> [a]
reverse ([BuildDepends] -> [BuildDepends])
-> Parsec (ErrorFancy Void) PackageName [BuildDepends]
-> Parsec (ErrorFancy Void) PackageName [BuildDepends]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [BuildDepends]
-> Parsec (ErrorFancy Void) PackageName [BuildDepends]
go [] where
  go :: [BuildDepends]
-> Parsec (ErrorFancy Void) PackageName [BuildDepends]
go [BuildDepends]
cur_deps = [BuildDepends]
-> Parsec (ErrorFancy Void) PackageName [BuildDepends]
targetBlockParsed [BuildDepends]
cur_deps Parsec (ErrorFancy Void) PackageName [BuildDepends]
-> Parsec (ErrorFancy Void) PackageName [BuildDepends]
-> Parsec (ErrorFancy Void) PackageName [BuildDepends]
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (ParsecT (ErrorFancy Void) PackageName Identity ()
forall e s (m :: * -> *). MonadParsec e s m => m ()
P.eof ParsecT (ErrorFancy Void) PackageName Identity ()
-> Parsec (ErrorFancy Void) PackageName [BuildDepends]
-> Parsec (ErrorFancy Void) PackageName [BuildDepends]
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> [BuildDepends]
-> Parsec (ErrorFancy Void) PackageName [BuildDepends]
forall (f :: * -> *) a. Applicative f => a -> f a
pure [BuildDepends]
cur_deps) Parsec (ErrorFancy Void) PackageName [BuildDepends]
-> Parsec (ErrorFancy Void) PackageName [BuildDepends]
-> Parsec (ErrorFancy Void) PackageName [BuildDepends]
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> [BuildDepends]
-> Parsec (ErrorFancy Void) PackageName [BuildDepends]
ignoreLine [BuildDepends]
cur_deps
  targetBlockParsed :: [BuildDepends]
-> Parsec (ErrorFancy Void) PackageName [BuildDepends]
targetBlockParsed [BuildDepends]
cur_deps = do
    BuildDepends
new_dep <- Parser BuildDepends
targetBlock
    [BuildDepends]
-> Parsec (ErrorFancy Void) PackageName [BuildDepends]
go (BuildDepends
new_dep BuildDepends -> [BuildDepends] -> [BuildDepends]
forall a. a -> [a] -> [a]
: [BuildDepends]
cur_deps)
  ignoreLine :: [BuildDepends]
-> Parsec (ErrorFancy Void) PackageName [BuildDepends]
ignoreLine [BuildDepends]
cur_deps = ParsecT (ErrorFancy Void) PackageName Identity Char
-> ParsecT (ErrorFancy Void) PackageName Identity ()
-> ParsecT (ErrorFancy Void) PackageName Identity String
forall (m :: * -> *) a end. MonadPlus m => m a -> m end -> m [a]
P.manyTill ParsecT (ErrorFancy Void) PackageName Identity Char
P.anyChar ParsecT (ErrorFancy Void) PackageName Identity ()
finishLine ParsecT (ErrorFancy Void) PackageName Identity String
-> Parsec (ErrorFancy Void) PackageName [BuildDepends]
-> Parsec (ErrorFancy Void) PackageName [BuildDepends]
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> [BuildDepends]
-> Parsec (ErrorFancy Void) PackageName [BuildDepends]
go [BuildDepends]
cur_deps