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
(Int -> InvalidYamlEvent -> ShowS)
-> (InvalidYamlEvent -> String)
-> ([InvalidYamlEvent] -> ShowS)
-> Show InvalidYamlEvent
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> InvalidYamlEvent -> ShowS
showsPrec :: Int -> InvalidYamlEvent -> ShowS
$cshow :: InvalidYamlEvent -> String
show :: InvalidYamlEvent -> String
$cshowList :: [InvalidYamlEvent] -> ShowS
showList :: [InvalidYamlEvent] -> ShowS
Show
  deriving anyclass Show InvalidYamlEvent
Typeable InvalidYamlEvent
(Typeable InvalidYamlEvent, Show InvalidYamlEvent) =>
(InvalidYamlEvent -> SomeException)
-> (SomeException -> Maybe InvalidYamlEvent)
-> (InvalidYamlEvent -> String)
-> Exception InvalidYamlEvent
SomeException -> Maybe InvalidYamlEvent
InvalidYamlEvent -> String
InvalidYamlEvent -> SomeException
forall e.
(Typeable e, Show e) =>
(e -> SomeException)
-> (SomeException -> Maybe e) -> (e -> String) -> Exception e
$ctoException :: InvalidYamlEvent -> SomeException
toException :: InvalidYamlEvent -> SomeException
$cfromException :: SomeException -> Maybe InvalidYamlEvent
fromException :: SomeException -> Maybe InvalidYamlEvent
$cdisplayException :: InvalidYamlEvent -> String
displayException :: InvalidYamlEvent -> String
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
  Event -> ConduitT i Event m ()
forall (m :: * -> *) o i. Monad m => o -> ConduitT i o m ()
yield (Event -> ConduitT i Event m ()) -> Event -> ConduitT i Event m ()
forall a b. (a -> b) -> a -> b
$ Tag -> MappingStyle -> Anchor -> Event
EventMappingStart Tag
NoTag MappingStyle
BlockMapping Anchor
forall a. Maybe a
Nothing
  Event -> ConduitT i Event m ()
forall (m :: * -> *) o i. Monad m => o -> ConduitT i o m ()
yield (Event -> ConduitT i Event m ()) -> Event -> ConduitT i Event m ()
forall a b. (a -> b) -> a -> b
$ ByteString -> Tag -> Style -> Anchor -> Event
EventScalar ByteString
tag Tag
NoTag Style
Plain Anchor
forall a. Maybe a
Nothing
  ConduitT i Event m ()
inner
  Event -> ConduitT i Event m ()
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
  Event -> ConduitT i Event m ()
forall (m :: * -> *) o i. Monad m => o -> ConduitT i o m ()
yield (Event -> ConduitT i Event m ()) -> Event -> ConduitT i Event m ()
forall a b. (a -> b) -> a -> b
$ Tag -> SequenceStyle -> Anchor -> Event
EventSequenceStart Tag
NoTag SequenceStyle
BlockSequence Anchor
forall a. Maybe a
Nothing
  ConduitT i Event m ()
inner
  Event -> ConduitT i Event m ()
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 = (Event -> Bool) -> (Event -> Bool) -> ConduitT Event Event m ()
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)