module CfnFlip.Libyaml
  ( InvalidYamlEvent(..)
  , makeMapping
  , makeSequence
  , startsMapOrSequence
  , isSameStart
  , isStartsEnd
  , takeMapOrSequenceC
  , module Text.Libyaml
  ) where

import CfnFlip.Prelude

import CfnFlip.Conduit
import Text.Libyaml
  (Event(..), MappingStyle(..), SequenceStyle(..), Style(..), Tag(..))

data InvalidYamlEvent = InvalidYamlEvent Event String
  deriving stock Int -> InvalidYamlEvent -> ShowS
[InvalidYamlEvent] -> ShowS
InvalidYamlEvent -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [InvalidYamlEvent] -> ShowS
$cshowList :: [InvalidYamlEvent] -> ShowS
show :: InvalidYamlEvent -> String
$cshow :: InvalidYamlEvent -> String
showsPrec :: Int -> InvalidYamlEvent -> ShowS
$cshowsPrec :: Int -> InvalidYamlEvent -> ShowS
Show
  deriving anyclass Show InvalidYamlEvent
Typeable InvalidYamlEvent
SomeException -> Maybe InvalidYamlEvent
InvalidYamlEvent -> String
InvalidYamlEvent -> SomeException
forall e.
Typeable e
-> Show e
-> (e -> SomeException)
-> (SomeException -> Maybe e)
-> (e -> String)
-> Exception e
displayException :: InvalidYamlEvent -> String
$cdisplayException :: InvalidYamlEvent -> String
fromException :: SomeException -> Maybe InvalidYamlEvent
$cfromException :: SomeException -> Maybe InvalidYamlEvent
toException :: InvalidYamlEvent -> SomeException
$ctoException :: InvalidYamlEvent -> SomeException
Exception

makeMapping
  :: Monad m => ByteString -> ConduitT i Event m () -> ConduitT i Event m ()
makeMapping :: forall (m :: * -> *) i.
Monad m =>
ByteString -> ConduitT i Event m () -> ConduitT i Event m ()
makeMapping ByteString
tag ConduitT i Event m ()
inner = do
  forall (m :: * -> *) o i. Monad m => o -> ConduitT i o m ()
yield forall a b. (a -> b) -> a -> b
$ Tag -> MappingStyle -> Anchor -> Event
EventMappingStart Tag
NoTag MappingStyle
BlockMapping forall a. Maybe a
Nothing
  forall (m :: * -> *) o i. Monad m => o -> ConduitT i o m ()
yield forall a b. (a -> b) -> a -> b
$ ByteString -> Tag -> Style -> Anchor -> Event
EventScalar ByteString
tag Tag
NoTag Style
Plain forall a. Maybe a
Nothing
  ConduitT i Event m ()
inner
  forall (m :: * -> *) o i. Monad m => o -> ConduitT i o m ()
yield Event
EventMappingEnd

makeSequence :: Monad m => ConduitT i Event m () -> ConduitT i Event m ()
makeSequence :: forall (m :: * -> *) i.
Monad m =>
ConduitT i Event m () -> ConduitT i Event m ()
makeSequence ConduitT i Event m ()
inner = do
  forall (m :: * -> *) o i. Monad m => o -> ConduitT i o m ()
yield forall a b. (a -> b) -> a -> b
$ Tag -> SequenceStyle -> Anchor -> Event
EventSequenceStart Tag
NoTag SequenceStyle
BlockSequence forall a. Maybe a
Nothing
  ConduitT i Event m ()
inner
  forall (m :: * -> *) o i. Monad m => o -> ConduitT i o m ()
yield Event
EventSequenceEnd

startsMapOrSequence :: Event -> Bool
startsMapOrSequence :: Event -> Bool
startsMapOrSequence = \case
  EventMappingStart{} -> Bool
True
  EventSequenceStart{} -> Bool
True
  Event
_ -> Bool
False

isSameStart :: Event -> Event -> Bool
Event
x isSameStart :: Event -> Event -> Bool
`isSameStart` Event
y = case (Event
x, Event
y) of
  (EventMappingStart{}, EventMappingStart{}) -> Bool
True
  (EventSequenceStart{}, EventSequenceStart{}) -> Bool
True
  (Event, Event)
_ -> Bool
False

isStartsEnd :: Event -> Event -> Bool
Event
x isStartsEnd :: Event -> Event -> Bool
`isStartsEnd` Event
y = case (Event
x, Event
y) of
  (EventMappingStart{}, EventMappingEnd{}) -> Bool
True
  (EventSequenceStart{}, EventSequenceEnd{}) -> Bool
True
  (Event, Event)
_ -> Bool
False

takeMapOrSequenceC :: Monad m => Event -> ConduitT Event Event m ()
takeMapOrSequenceC :: forall (m :: * -> *). Monad m => Event -> ConduitT Event Event m ()
takeMapOrSequenceC Event
e = forall (m :: * -> *) a.
Monad m =>
(a -> Bool) -> (a -> Bool) -> ConduitT a a m ()
takeBalancedC (Event -> Event -> Bool
isSameStart Event
e) (Event -> Event -> Bool
isStartsEnd Event
e)