module Buffet.Parse.ParseInternal
  ( get
  ) where

import qualified Buffet.Ir.Ir as Ir
import qualified Buffet.Parse.Menu as Menu
import qualified Buffet.Parse.ParseDish as ParseDish
import qualified Buffet.Parse.ParseMenu as ParseMenu
import qualified Buffet.Toolbox.ExceptionTools as ExceptionTools
import qualified Control.Exception as Exception
import qualified Control.Monad as Monad
import qualified Language.Docker as Docker
import qualified Language.Docker.Parser as Parser
import Prelude (FilePath, IO, Show, ($), (.), fmap, pure, show)

newtype Exception =
  Exception Parser.Error

instance Show Exception where
  show :: Exception -> String
show (Exception Error
error) = Error -> String
forall s e.
(VisualStream s, TraversableStream s, ShowErrorComponent e) =>
ParseErrorBundle s e -> String
Docker.errorBundlePretty Error
error

instance Exception.Exception Exception

get :: FilePath -> IO Ir.Buffet
get :: String -> IO Buffet
get = String -> IO Menu
ParseMenu.get (String -> IO Menu) -> (Menu -> IO Buffet) -> String -> IO Buffet
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
Monad.>=> Menu -> IO Buffet
parseBuffet

parseBuffet :: Menu.Menu -> IO Ir.Buffet
parseBuffet :: Menu -> IO Buffet
parseBuffet Menu
menu = do
  Map Option Dish
optionToDish <-
    Map Option (IO Dish) -> IO (Map Option Dish)
forall (t :: * -> *) a. Traversable t => t (IO a) -> IO (t a)
ExceptionTools.sequenceAccumulatingExceptions (Map Option (IO Dish) -> IO (Map Option Dish))
-> (Map Option String -> Map Option (IO Dish))
-> Map Option String
-> IO (Map Option Dish)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (String -> IO Dish) -> Map Option String -> Map Option (IO Dish)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap String -> IO Dish
ParseDish.get (Map Option String -> IO (Map Option Dish))
-> Map Option String -> IO (Map Option Dish)
forall a b. (a -> b) -> a -> b
$
    Menu -> Map Option String
Menu.optionToDish Menu
menu
  Buffet -> IO Buffet
forall (f :: * -> *) a. Applicative f => a -> f a
pure
    Buffet :: Text -> Map Option Dish -> Buffet
Ir.Buffet
      { copyDummySourcePath :: Text
Ir.copyDummySourcePath = Menu -> Text
Menu.copyDummySourcePath Menu
menu
      , optionToDish :: Map Option Dish
Ir.optionToDish = Map Option Dish
optionToDish
      }