--------------------------------------------------------------------------------
{-# LANGUAGE GADTs                      #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE OverloadedStrings          #-}
{-# LANGUAGE TemplateHaskell            #-}
module Patat.Presentation.Settings
    ( PresentationSettings (..)
    , defaultPresentationSettings

    , Wrap (..)
    , AutoOr (..)
    , MarginSettings (..)

    , ExtensionList (..)
    , defaultExtensionList

    , ImageSettings (..)

    , EvalSettingsMap (..)
    , EvalSettingsContainer (..)
    , EvalSettings (..)

    , SpeakerNotesSettings (..)

    , TransitionSettings (..)

    , LinkSettings (..)

    , parseSlideSettings
    ) where


--------------------------------------------------------------------------------
import           Control.Applicative    ((<|>))
import           Control.Monad          (mplus, unless)
import qualified Data.Aeson.Extended    as A
import qualified Data.Aeson.TH.Extended as A
import           Data.Bifunctor         (first)
import           Data.CaseInsensitive   (CI)
import qualified Data.CaseInsensitive   as CI
import qualified Data.Foldable          as Foldable
import           Data.Function          (on)
import qualified Data.HashMap.Strict    as HMS
import           Data.List              (intercalate)
import qualified Data.Text              as T
import qualified Patat.Theme            as Theme
import           Prelude
import qualified Text.Pandoc            as Pandoc
import           Text.Read              (readMaybe)


--------------------------------------------------------------------------------
-- | These are patat-specific settings.  That is where they differ from more
-- general metadata (author, title...)
data PresentationSettings = PresentationSettings
    { PresentationSettings -> Maybe (FlexibleNum Int)
psRows              :: !(Maybe (A.FlexibleNum Int))
    , PresentationSettings -> Maybe (FlexibleNum Int)
psColumns           :: !(Maybe (A.FlexibleNum Int))
    , PresentationSettings -> Maybe MarginSettings
psMargins           :: !(Maybe MarginSettings)
    , PresentationSettings -> Maybe Wrap
psWrap              :: !(Maybe Wrap)
    , PresentationSettings -> Maybe (FlexibleNum Int)
psTabStop           :: !(Maybe (A.FlexibleNum Int))
    , PresentationSettings -> Maybe Theme
psTheme             :: !(Maybe Theme.Theme)
    , PresentationSettings -> Maybe Bool
psIncrementalLists  :: !(Maybe Bool)
    , PresentationSettings -> Maybe (FlexibleNum Int)
psAutoAdvanceDelay  :: !(Maybe (A.FlexibleNum Int))
    , PresentationSettings -> Maybe Int
psSlideLevel        :: !(Maybe Int)
    , PresentationSettings -> Maybe ExtensionList
psPandocExtensions  :: !(Maybe ExtensionList)
    , PresentationSettings -> Maybe ImageSettings
psImages            :: !(Maybe ImageSettings)
    , PresentationSettings -> Maybe Bool
psBreadcrumbs       :: !(Maybe Bool)
    , PresentationSettings -> Maybe EvalSettingsMap
psEval              :: !(Maybe EvalSettingsMap)
    , PresentationSettings -> Maybe Bool
psSlideNumber       :: !(Maybe Bool)
    , PresentationSettings -> Maybe [String]
psSyntaxDefinitions :: !(Maybe [FilePath])
    , PresentationSettings -> Maybe SpeakerNotesSettings
psSpeakerNotes      :: !(Maybe SpeakerNotesSettings)
    , PresentationSettings -> Maybe TransitionSettings
psTransition        :: !(Maybe TransitionSettings)
    , PresentationSettings -> Maybe LinkSettings
psLinks             :: !(Maybe LinkSettings)
    } deriving (PresentationSettings -> PresentationSettings -> Bool
(PresentationSettings -> PresentationSettings -> Bool)
-> (PresentationSettings -> PresentationSettings -> Bool)
-> Eq PresentationSettings
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: PresentationSettings -> PresentationSettings -> Bool
== :: PresentationSettings -> PresentationSettings -> Bool
$c/= :: PresentationSettings -> PresentationSettings -> Bool
/= :: PresentationSettings -> PresentationSettings -> Bool
Eq, Int -> PresentationSettings -> ShowS
[PresentationSettings] -> ShowS
PresentationSettings -> String
(Int -> PresentationSettings -> ShowS)
-> (PresentationSettings -> String)
-> ([PresentationSettings] -> ShowS)
-> Show PresentationSettings
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> PresentationSettings -> ShowS
showsPrec :: Int -> PresentationSettings -> ShowS
$cshow :: PresentationSettings -> String
show :: PresentationSettings -> String
$cshowList :: [PresentationSettings] -> ShowS
showList :: [PresentationSettings] -> ShowS
Show)


--------------------------------------------------------------------------------
instance Semigroup PresentationSettings where
    PresentationSettings
l <> :: PresentationSettings
-> PresentationSettings -> PresentationSettings
<> PresentationSettings
r = PresentationSettings
        { psRows :: Maybe (FlexibleNum Int)
psRows              = (Maybe (FlexibleNum Int)
 -> Maybe (FlexibleNum Int) -> Maybe (FlexibleNum Int))
-> (PresentationSettings -> Maybe (FlexibleNum Int))
-> PresentationSettings
-> PresentationSettings
-> Maybe (FlexibleNum Int)
forall b c a. (b -> b -> c) -> (a -> b) -> a -> a -> c
on Maybe (FlexibleNum Int)
-> Maybe (FlexibleNum Int) -> Maybe (FlexibleNum Int)
forall a. Maybe a -> Maybe a -> Maybe a
forall (m :: * -> *) a. MonadPlus m => m a -> m a -> m a
mplus PresentationSettings -> Maybe (FlexibleNum Int)
psRows              PresentationSettings
l PresentationSettings
r
        , psColumns :: Maybe (FlexibleNum Int)
psColumns           = (Maybe (FlexibleNum Int)
 -> Maybe (FlexibleNum Int) -> Maybe (FlexibleNum Int))
-> (PresentationSettings -> Maybe (FlexibleNum Int))
-> PresentationSettings
-> PresentationSettings
-> Maybe (FlexibleNum Int)
forall b c a. (b -> b -> c) -> (a -> b) -> a -> a -> c
on Maybe (FlexibleNum Int)
-> Maybe (FlexibleNum Int) -> Maybe (FlexibleNum Int)
forall a. Maybe a -> Maybe a -> Maybe a
forall (m :: * -> *) a. MonadPlus m => m a -> m a -> m a
mplus PresentationSettings -> Maybe (FlexibleNum Int)
psColumns           PresentationSettings
l PresentationSettings
r
        , psMargins :: Maybe MarginSettings
psMargins           = (Maybe MarginSettings
 -> Maybe MarginSettings -> Maybe MarginSettings)
-> (PresentationSettings -> Maybe MarginSettings)
-> PresentationSettings
-> PresentationSettings
-> Maybe MarginSettings
forall b c a. (b -> b -> c) -> (a -> b) -> a -> a -> c
on Maybe MarginSettings
-> Maybe MarginSettings -> Maybe MarginSettings
forall a. Semigroup a => a -> a -> a
(<>)  PresentationSettings -> Maybe MarginSettings
psMargins           PresentationSettings
l PresentationSettings
r
        , psWrap :: Maybe Wrap
psWrap              = (Maybe Wrap -> Maybe Wrap -> Maybe Wrap)
-> (PresentationSettings -> Maybe Wrap)
-> PresentationSettings
-> PresentationSettings
-> Maybe Wrap
forall b c a. (b -> b -> c) -> (a -> b) -> a -> a -> c
on Maybe Wrap -> Maybe Wrap -> Maybe Wrap
forall a. Maybe a -> Maybe a -> Maybe a
forall (m :: * -> *) a. MonadPlus m => m a -> m a -> m a
mplus PresentationSettings -> Maybe Wrap
psWrap              PresentationSettings
l PresentationSettings
r
        , psTabStop :: Maybe (FlexibleNum Int)
psTabStop           = (Maybe (FlexibleNum Int)
 -> Maybe (FlexibleNum Int) -> Maybe (FlexibleNum Int))
-> (PresentationSettings -> Maybe (FlexibleNum Int))
-> PresentationSettings
-> PresentationSettings
-> Maybe (FlexibleNum Int)
forall b c a. (b -> b -> c) -> (a -> b) -> a -> a -> c
on Maybe (FlexibleNum Int)
-> Maybe (FlexibleNum Int) -> Maybe (FlexibleNum Int)
forall a. Maybe a -> Maybe a -> Maybe a
forall (m :: * -> *) a. MonadPlus m => m a -> m a -> m a
mplus PresentationSettings -> Maybe (FlexibleNum Int)
psTabStop           PresentationSettings
l PresentationSettings
r
        , psTheme :: Maybe Theme
psTheme             = (Maybe Theme -> Maybe Theme -> Maybe Theme)
-> (PresentationSettings -> Maybe Theme)
-> PresentationSettings
-> PresentationSettings
-> Maybe Theme
forall b c a. (b -> b -> c) -> (a -> b) -> a -> a -> c
on Maybe Theme -> Maybe Theme -> Maybe Theme
forall a. Semigroup a => a -> a -> a
(<>)  PresentationSettings -> Maybe Theme
psTheme             PresentationSettings
l PresentationSettings
r
        , psIncrementalLists :: Maybe Bool
psIncrementalLists  = (Maybe Bool -> Maybe Bool -> Maybe Bool)
-> (PresentationSettings -> Maybe Bool)
-> PresentationSettings
-> PresentationSettings
-> Maybe Bool
forall b c a. (b -> b -> c) -> (a -> b) -> a -> a -> c
on Maybe Bool -> Maybe Bool -> Maybe Bool
forall a. Maybe a -> Maybe a -> Maybe a
forall (m :: * -> *) a. MonadPlus m => m a -> m a -> m a
mplus PresentationSettings -> Maybe Bool
psIncrementalLists  PresentationSettings
l PresentationSettings
r
        , psAutoAdvanceDelay :: Maybe (FlexibleNum Int)
psAutoAdvanceDelay  = (Maybe (FlexibleNum Int)
 -> Maybe (FlexibleNum Int) -> Maybe (FlexibleNum Int))
-> (PresentationSettings -> Maybe (FlexibleNum Int))
-> PresentationSettings
-> PresentationSettings
-> Maybe (FlexibleNum Int)
forall b c a. (b -> b -> c) -> (a -> b) -> a -> a -> c
on Maybe (FlexibleNum Int)
-> Maybe (FlexibleNum Int) -> Maybe (FlexibleNum Int)
forall a. Maybe a -> Maybe a -> Maybe a
forall (m :: * -> *) a. MonadPlus m => m a -> m a -> m a
mplus PresentationSettings -> Maybe (FlexibleNum Int)
psAutoAdvanceDelay  PresentationSettings
l PresentationSettings
r
        , psSlideLevel :: Maybe Int
psSlideLevel        = (Maybe Int -> Maybe Int -> Maybe Int)
-> (PresentationSettings -> Maybe Int)
-> PresentationSettings
-> PresentationSettings
-> Maybe Int
forall b c a. (b -> b -> c) -> (a -> b) -> a -> a -> c
on Maybe Int -> Maybe Int -> Maybe Int
forall a. Maybe a -> Maybe a -> Maybe a
forall (m :: * -> *) a. MonadPlus m => m a -> m a -> m a
mplus PresentationSettings -> Maybe Int
psSlideLevel        PresentationSettings
l PresentationSettings
r
        , psPandocExtensions :: Maybe ExtensionList
psPandocExtensions  = (Maybe ExtensionList -> Maybe ExtensionList -> Maybe ExtensionList)
-> (PresentationSettings -> Maybe ExtensionList)
-> PresentationSettings
-> PresentationSettings
-> Maybe ExtensionList
forall b c a. (b -> b -> c) -> (a -> b) -> a -> a -> c
on Maybe ExtensionList -> Maybe ExtensionList -> Maybe ExtensionList
forall a. Maybe a -> Maybe a -> Maybe a
forall (m :: * -> *) a. MonadPlus m => m a -> m a -> m a
mplus PresentationSettings -> Maybe ExtensionList
psPandocExtensions  PresentationSettings
l PresentationSettings
r
        , psImages :: Maybe ImageSettings
psImages            = (Maybe ImageSettings -> Maybe ImageSettings -> Maybe ImageSettings)
-> (PresentationSettings -> Maybe ImageSettings)
-> PresentationSettings
-> PresentationSettings
-> Maybe ImageSettings
forall b c a. (b -> b -> c) -> (a -> b) -> a -> a -> c
on Maybe ImageSettings -> Maybe ImageSettings -> Maybe ImageSettings
forall a. Maybe a -> Maybe a -> Maybe a
forall (m :: * -> *) a. MonadPlus m => m a -> m a -> m a
mplus PresentationSettings -> Maybe ImageSettings
psImages            PresentationSettings
l PresentationSettings
r
        , psBreadcrumbs :: Maybe Bool
psBreadcrumbs       = (Maybe Bool -> Maybe Bool -> Maybe Bool)
-> (PresentationSettings -> Maybe Bool)
-> PresentationSettings
-> PresentationSettings
-> Maybe Bool
forall b c a. (b -> b -> c) -> (a -> b) -> a -> a -> c
on Maybe Bool -> Maybe Bool -> Maybe Bool
forall a. Maybe a -> Maybe a -> Maybe a
forall (m :: * -> *) a. MonadPlus m => m a -> m a -> m a
mplus PresentationSettings -> Maybe Bool
psBreadcrumbs       PresentationSettings
l PresentationSettings
r
        , psEval :: Maybe EvalSettingsMap
psEval              = (Maybe EvalSettingsMap
 -> Maybe EvalSettingsMap -> Maybe EvalSettingsMap)
-> (PresentationSettings -> Maybe EvalSettingsMap)
-> PresentationSettings
-> PresentationSettings
-> Maybe EvalSettingsMap
forall b c a. (b -> b -> c) -> (a -> b) -> a -> a -> c
on Maybe EvalSettingsMap
-> Maybe EvalSettingsMap -> Maybe EvalSettingsMap
forall a. Semigroup a => a -> a -> a
(<>)  PresentationSettings -> Maybe EvalSettingsMap
psEval              PresentationSettings
l PresentationSettings
r
        , psSlideNumber :: Maybe Bool
psSlideNumber       = (Maybe Bool -> Maybe Bool -> Maybe Bool)
-> (PresentationSettings -> Maybe Bool)
-> PresentationSettings
-> PresentationSettings
-> Maybe Bool
forall b c a. (b -> b -> c) -> (a -> b) -> a -> a -> c
on Maybe Bool -> Maybe Bool -> Maybe Bool
forall a. Maybe a -> Maybe a -> Maybe a
forall (m :: * -> *) a. MonadPlus m => m a -> m a -> m a
mplus PresentationSettings -> Maybe Bool
psSlideNumber       PresentationSettings
l PresentationSettings
r
        , psSyntaxDefinitions :: Maybe [String]
psSyntaxDefinitions = (Maybe [String] -> Maybe [String] -> Maybe [String])
-> (PresentationSettings -> Maybe [String])
-> PresentationSettings
-> PresentationSettings
-> Maybe [String]
forall b c a. (b -> b -> c) -> (a -> b) -> a -> a -> c
on Maybe [String] -> Maybe [String] -> Maybe [String]
forall a. Semigroup a => a -> a -> a
(<>)  PresentationSettings -> Maybe [String]
psSyntaxDefinitions PresentationSettings
l PresentationSettings
r
        , psSpeakerNotes :: Maybe SpeakerNotesSettings
psSpeakerNotes      = (Maybe SpeakerNotesSettings
 -> Maybe SpeakerNotesSettings -> Maybe SpeakerNotesSettings)
-> (PresentationSettings -> Maybe SpeakerNotesSettings)
-> PresentationSettings
-> PresentationSettings
-> Maybe SpeakerNotesSettings
forall b c a. (b -> b -> c) -> (a -> b) -> a -> a -> c
on Maybe SpeakerNotesSettings
-> Maybe SpeakerNotesSettings -> Maybe SpeakerNotesSettings
forall a. Maybe a -> Maybe a -> Maybe a
forall (m :: * -> *) a. MonadPlus m => m a -> m a -> m a
mplus PresentationSettings -> Maybe SpeakerNotesSettings
psSpeakerNotes      PresentationSettings
l PresentationSettings
r
        , psTransition :: Maybe TransitionSettings
psTransition        = (Maybe TransitionSettings
 -> Maybe TransitionSettings -> Maybe TransitionSettings)
-> (PresentationSettings -> Maybe TransitionSettings)
-> PresentationSettings
-> PresentationSettings
-> Maybe TransitionSettings
forall b c a. (b -> b -> c) -> (a -> b) -> a -> a -> c
on Maybe TransitionSettings
-> Maybe TransitionSettings -> Maybe TransitionSettings
forall a. Maybe a -> Maybe a -> Maybe a
forall (m :: * -> *) a. MonadPlus m => m a -> m a -> m a
mplus PresentationSettings -> Maybe TransitionSettings
psTransition        PresentationSettings
l PresentationSettings
r
        , psLinks :: Maybe LinkSettings
psLinks             = (Maybe LinkSettings -> Maybe LinkSettings -> Maybe LinkSettings)
-> (PresentationSettings -> Maybe LinkSettings)
-> PresentationSettings
-> PresentationSettings
-> Maybe LinkSettings
forall b c a. (b -> b -> c) -> (a -> b) -> a -> a -> c
on Maybe LinkSettings -> Maybe LinkSettings -> Maybe LinkSettings
forall a. Semigroup a => a -> a -> a
(<>)  PresentationSettings -> Maybe LinkSettings
psLinks             PresentationSettings
l PresentationSettings
r
        }


--------------------------------------------------------------------------------
instance Monoid PresentationSettings where
    mappend :: PresentationSettings
-> PresentationSettings -> PresentationSettings
mappend = PresentationSettings
-> PresentationSettings -> PresentationSettings
forall a. Semigroup a => a -> a -> a
(<>)
    mempty :: PresentationSettings
mempty  = Maybe (FlexibleNum Int)
-> Maybe (FlexibleNum Int)
-> Maybe MarginSettings
-> Maybe Wrap
-> Maybe (FlexibleNum Int)
-> Maybe Theme
-> Maybe Bool
-> Maybe (FlexibleNum Int)
-> Maybe Int
-> Maybe ExtensionList
-> Maybe ImageSettings
-> Maybe Bool
-> Maybe EvalSettingsMap
-> Maybe Bool
-> Maybe [String]
-> Maybe SpeakerNotesSettings
-> Maybe TransitionSettings
-> Maybe LinkSettings
-> PresentationSettings
PresentationSettings
                Maybe (FlexibleNum Int)
forall a. Maybe a
Nothing Maybe (FlexibleNum Int)
forall a. Maybe a
Nothing Maybe MarginSettings
forall a. Maybe a
Nothing Maybe Wrap
forall a. Maybe a
Nothing Maybe (FlexibleNum Int)
forall a. Maybe a
Nothing Maybe Theme
forall a. Maybe a
Nothing Maybe Bool
forall a. Maybe a
Nothing Maybe (FlexibleNum Int)
forall a. Maybe a
Nothing
                Maybe Int
forall a. Maybe a
Nothing Maybe ExtensionList
forall a. Maybe a
Nothing Maybe ImageSettings
forall a. Maybe a
Nothing Maybe Bool
forall a. Maybe a
Nothing Maybe EvalSettingsMap
forall a. Maybe a
Nothing Maybe Bool
forall a. Maybe a
Nothing Maybe [String]
forall a. Maybe a
Nothing Maybe SpeakerNotesSettings
forall a. Maybe a
Nothing
                Maybe TransitionSettings
forall a. Maybe a
Nothing Maybe LinkSettings
forall a. Maybe a
Nothing


--------------------------------------------------------------------------------
defaultPresentationSettings :: PresentationSettings
defaultPresentationSettings :: PresentationSettings
defaultPresentationSettings = PresentationSettings
forall a. Monoid a => a
mempty
    { psMargins = Nothing
    , psTheme   = Just Theme.defaultTheme
    }


--------------------------------------------------------------------------------
data Wrap = NoWrap | AutoWrap | WrapAt Int deriving (Wrap -> Wrap -> Bool
(Wrap -> Wrap -> Bool) -> (Wrap -> Wrap -> Bool) -> Eq Wrap
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Wrap -> Wrap -> Bool
== :: Wrap -> Wrap -> Bool
$c/= :: Wrap -> Wrap -> Bool
/= :: Wrap -> Wrap -> Bool
Eq, Int -> Wrap -> ShowS
[Wrap] -> ShowS
Wrap -> String
(Int -> Wrap -> ShowS)
-> (Wrap -> String) -> ([Wrap] -> ShowS) -> Show Wrap
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Wrap -> ShowS
showsPrec :: Int -> Wrap -> ShowS
$cshow :: Wrap -> String
show :: Wrap -> String
$cshowList :: [Wrap] -> ShowS
showList :: [Wrap] -> ShowS
Show)


--------------------------------------------------------------------------------
instance A.FromJSON Wrap where
    parseJSON :: Value -> Parser Wrap
parseJSON Value
val =
        ((\Bool
w -> if Bool
w then Wrap
AutoWrap else Wrap
NoWrap) (Bool -> Wrap) -> Parser Bool -> Parser Wrap
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Value -> Parser Bool
forall a. FromJSON a => Value -> Parser a
A.parseJSON Value
val) Parser Wrap -> Parser Wrap -> Parser Wrap
forall a. Parser a -> Parser a -> Parser a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
        (Int -> Wrap
WrapAt (Int -> Wrap) -> Parser Int -> Parser Wrap
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Value -> Parser Int
forall a. FromJSON a => Value -> Parser a
A.parseJSON Value
val)


--------------------------------------------------------------------------------
data AutoOr a = Auto | NotAuto a deriving (AutoOr a -> AutoOr a -> Bool
(AutoOr a -> AutoOr a -> Bool)
-> (AutoOr a -> AutoOr a -> Bool) -> Eq (AutoOr a)
forall a. Eq a => AutoOr a -> AutoOr a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall a. Eq a => AutoOr a -> AutoOr a -> Bool
== :: AutoOr a -> AutoOr a -> Bool
$c/= :: forall a. Eq a => AutoOr a -> AutoOr a -> Bool
/= :: AutoOr a -> AutoOr a -> Bool
Eq, Int -> AutoOr a -> ShowS
[AutoOr a] -> ShowS
AutoOr a -> String
(Int -> AutoOr a -> ShowS)
-> (AutoOr a -> String) -> ([AutoOr a] -> ShowS) -> Show (AutoOr a)
forall a. Show a => Int -> AutoOr a -> ShowS
forall a. Show a => [AutoOr a] -> ShowS
forall a. Show a => AutoOr a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall a. Show a => Int -> AutoOr a -> ShowS
showsPrec :: Int -> AutoOr a -> ShowS
$cshow :: forall a. Show a => AutoOr a -> String
show :: AutoOr a -> String
$cshowList :: forall a. Show a => [AutoOr a] -> ShowS
showList :: [AutoOr a] -> ShowS
Show)


--------------------------------------------------------------------------------
instance A.FromJSON a => A.FromJSON (AutoOr a) where
    parseJSON :: Value -> Parser (AutoOr a)
parseJSON (A.String Text
"auto") = AutoOr a -> Parser (AutoOr a)
forall a. a -> Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure AutoOr a
forall a. AutoOr a
Auto
    parseJSON Value
val               = a -> AutoOr a
forall a. a -> AutoOr a
NotAuto (a -> AutoOr a) -> Parser a -> Parser (AutoOr a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Value -> Parser a
forall a. FromJSON a => Value -> Parser a
A.parseJSON Value
val


--------------------------------------------------------------------------------
data MarginSettings = MarginSettings
    { MarginSettings -> Maybe (AutoOr (FlexibleNum Int))
msTop   :: !(Maybe (AutoOr (A.FlexibleNum Int)))
    , MarginSettings -> Maybe (AutoOr (FlexibleNum Int))
msLeft  :: !(Maybe (AutoOr (A.FlexibleNum Int)))
    , MarginSettings -> Maybe (AutoOr (FlexibleNum Int))
msRight :: !(Maybe (AutoOr (A.FlexibleNum Int)))
    } deriving (MarginSettings -> MarginSettings -> Bool
(MarginSettings -> MarginSettings -> Bool)
-> (MarginSettings -> MarginSettings -> Bool) -> Eq MarginSettings
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MarginSettings -> MarginSettings -> Bool
== :: MarginSettings -> MarginSettings -> Bool
$c/= :: MarginSettings -> MarginSettings -> Bool
/= :: MarginSettings -> MarginSettings -> Bool
Eq, Int -> MarginSettings -> ShowS
[MarginSettings] -> ShowS
MarginSettings -> String
(Int -> MarginSettings -> ShowS)
-> (MarginSettings -> String)
-> ([MarginSettings] -> ShowS)
-> Show MarginSettings
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MarginSettings -> ShowS
showsPrec :: Int -> MarginSettings -> ShowS
$cshow :: MarginSettings -> String
show :: MarginSettings -> String
$cshowList :: [MarginSettings] -> ShowS
showList :: [MarginSettings] -> ShowS
Show)


--------------------------------------------------------------------------------
instance Semigroup MarginSettings where
    MarginSettings
l <> :: MarginSettings -> MarginSettings -> MarginSettings
<> MarginSettings
r = MarginSettings
        { msTop :: Maybe (AutoOr (FlexibleNum Int))
msTop   = (Maybe (AutoOr (FlexibleNum Int))
 -> Maybe (AutoOr (FlexibleNum Int))
 -> Maybe (AutoOr (FlexibleNum Int)))
-> (MarginSettings -> Maybe (AutoOr (FlexibleNum Int)))
-> MarginSettings
-> MarginSettings
-> Maybe (AutoOr (FlexibleNum Int))
forall b c a. (b -> b -> c) -> (a -> b) -> a -> a -> c
on Maybe (AutoOr (FlexibleNum Int))
-> Maybe (AutoOr (FlexibleNum Int))
-> Maybe (AutoOr (FlexibleNum Int))
forall a. Maybe a -> Maybe a -> Maybe a
forall (m :: * -> *) a. MonadPlus m => m a -> m a -> m a
mplus MarginSettings -> Maybe (AutoOr (FlexibleNum Int))
msTop   MarginSettings
l MarginSettings
r
        , msLeft :: Maybe (AutoOr (FlexibleNum Int))
msLeft  = (Maybe (AutoOr (FlexibleNum Int))
 -> Maybe (AutoOr (FlexibleNum Int))
 -> Maybe (AutoOr (FlexibleNum Int)))
-> (MarginSettings -> Maybe (AutoOr (FlexibleNum Int)))
-> MarginSettings
-> MarginSettings
-> Maybe (AutoOr (FlexibleNum Int))
forall b c a. (b -> b -> c) -> (a -> b) -> a -> a -> c
on Maybe (AutoOr (FlexibleNum Int))
-> Maybe (AutoOr (FlexibleNum Int))
-> Maybe (AutoOr (FlexibleNum Int))
forall a. Maybe a -> Maybe a -> Maybe a
forall (m :: * -> *) a. MonadPlus m => m a -> m a -> m a
mplus MarginSettings -> Maybe (AutoOr (FlexibleNum Int))
msLeft  MarginSettings
l MarginSettings
r
        , msRight :: Maybe (AutoOr (FlexibleNum Int))
msRight = (Maybe (AutoOr (FlexibleNum Int))
 -> Maybe (AutoOr (FlexibleNum Int))
 -> Maybe (AutoOr (FlexibleNum Int)))
-> (MarginSettings -> Maybe (AutoOr (FlexibleNum Int)))
-> MarginSettings
-> MarginSettings
-> Maybe (AutoOr (FlexibleNum Int))
forall b c a. (b -> b -> c) -> (a -> b) -> a -> a -> c
on Maybe (AutoOr (FlexibleNum Int))
-> Maybe (AutoOr (FlexibleNum Int))
-> Maybe (AutoOr (FlexibleNum Int))
forall a. Maybe a -> Maybe a -> Maybe a
forall (m :: * -> *) a. MonadPlus m => m a -> m a -> m a
mplus MarginSettings -> Maybe (AutoOr (FlexibleNum Int))
msRight MarginSettings
l MarginSettings
r
        }


--------------------------------------------------------------------------------
instance Monoid MarginSettings where
    mappend :: MarginSettings -> MarginSettings -> MarginSettings
mappend = MarginSettings -> MarginSettings -> MarginSettings
forall a. Semigroup a => a -> a -> a
(<>)
    mempty :: MarginSettings
mempty  = Maybe (AutoOr (FlexibleNum Int))
-> Maybe (AutoOr (FlexibleNum Int))
-> Maybe (AutoOr (FlexibleNum Int))
-> MarginSettings
MarginSettings Maybe (AutoOr (FlexibleNum Int))
forall a. Maybe a
Nothing Maybe (AutoOr (FlexibleNum Int))
forall a. Maybe a
Nothing Maybe (AutoOr (FlexibleNum Int))
forall a. Maybe a
Nothing


--------------------------------------------------------------------------------
newtype ExtensionList = ExtensionList {ExtensionList -> Extensions
unExtensionList :: Pandoc.Extensions}
    deriving (ExtensionList -> ExtensionList -> Bool
(ExtensionList -> ExtensionList -> Bool)
-> (ExtensionList -> ExtensionList -> Bool) -> Eq ExtensionList
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ExtensionList -> ExtensionList -> Bool
== :: ExtensionList -> ExtensionList -> Bool
$c/= :: ExtensionList -> ExtensionList -> Bool
/= :: ExtensionList -> ExtensionList -> Bool
Eq, Int -> ExtensionList -> ShowS
[ExtensionList] -> ShowS
ExtensionList -> String
(Int -> ExtensionList -> ShowS)
-> (ExtensionList -> String)
-> ([ExtensionList] -> ShowS)
-> Show ExtensionList
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ExtensionList -> ShowS
showsPrec :: Int -> ExtensionList -> ShowS
$cshow :: ExtensionList -> String
show :: ExtensionList -> String
$cshowList :: [ExtensionList] -> ShowS
showList :: [ExtensionList] -> ShowS
Show)


--------------------------------------------------------------------------------
instance A.FromJSON ExtensionList where
    parseJSON :: Value -> Parser ExtensionList
parseJSON = String
-> (Array -> Parser ExtensionList) -> Value -> Parser ExtensionList
forall a. String -> (Array -> Parser a) -> Value -> Parser a
A.withArray String
"FromJSON ExtensionList" ((Array -> Parser ExtensionList) -> Value -> Parser ExtensionList)
-> (Array -> Parser ExtensionList) -> Value -> Parser ExtensionList
forall a b. (a -> b) -> a -> b
$
        ([Extensions] -> ExtensionList)
-> Parser [Extensions] -> Parser ExtensionList
forall a b. (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Extensions -> ExtensionList
ExtensionList (Extensions -> ExtensionList)
-> ([Extensions] -> Extensions) -> [Extensions] -> ExtensionList
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Extensions] -> Extensions
forall a. Monoid a => [a] -> a
mconcat) (Parser [Extensions] -> Parser ExtensionList)
-> (Array -> Parser [Extensions]) -> Array -> Parser ExtensionList
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Value -> Parser Extensions) -> [Value] -> Parser [Extensions]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM Value -> Parser Extensions
parseExt ([Value] -> Parser [Extensions])
-> (Array -> [Value]) -> Array -> Parser [Extensions]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Array -> [Value]
forall a. Vector a -> [a]
forall (t :: * -> *) a. Foldable t => t a -> [a]
Foldable.toList
      where
        parseExt :: Value -> Parser Extensions
parseExt = String -> (Text -> Parser Extensions) -> Value -> Parser Extensions
forall a. String -> (Text -> Parser a) -> Value -> Parser a
A.withText String
"FromJSON ExtensionList" ((Text -> Parser Extensions) -> Value -> Parser Extensions)
-> (Text -> Parser Extensions) -> Value -> Parser Extensions
forall a b. (a -> b) -> a -> b
$ \Text
txt -> case Text
txt of
            -- Our default extensions
            Text
"patat_extensions" -> Extensions -> Parser Extensions
forall a. a -> Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return (ExtensionList -> Extensions
unExtensionList ExtensionList
defaultExtensionList)

            -- Individuals
            Text
_ -> case String -> Maybe Extension
forall a. Read a => String -> Maybe a
readMaybe (String
"Ext_" String -> ShowS
forall a. [a] -> [a] -> [a]
++ Text -> String
T.unpack Text
txt) of
                Just Extension
e  -> Extensions -> Parser Extensions
forall a. a -> Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return (Extensions -> Parser Extensions)
-> Extensions -> Parser Extensions
forall a b. (a -> b) -> a -> b
$ [Extension] -> Extensions
Pandoc.extensionsFromList [Extension
e]
                Maybe Extension
Nothing -> String -> Parser Extensions
forall a. String -> Parser a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String -> Parser Extensions) -> String -> Parser Extensions
forall a b. (a -> b) -> a -> b
$
                    String
"Unknown extension: " String -> ShowS
forall a. [a] -> [a] -> [a]
++ Text -> String
forall a. Show a => a -> String
show Text
txt String -> ShowS
forall a. [a] -> [a] -> [a]
++
                    String
", known extensions are: " String -> ShowS
forall a. [a] -> [a] -> [a]
++
                    String -> [String] -> String
forall a. [a] -> [[a]] -> [a]
intercalate String
", " ((Extension -> String) -> [Extension] -> [String]
forall a b. (a -> b) -> [a] -> [b]
map (Int -> ShowS
forall a. Int -> [a] -> [a]
drop Int
4 ShowS -> (Extension -> String) -> Extension -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Extension -> String
forall a. Show a => a -> String
show) [Extension]
allExts)
          where
            -- This is an approximation since we can't enumerate extensions
            -- anymore in the latest pandoc...
            allExts :: [Extension]
allExts = Extensions -> [Extension]
Pandoc.extensionsToList (Extensions -> [Extension]) -> Extensions -> [Extension]
forall a b. (a -> b) -> a -> b
$
                Text -> Extensions
Pandoc.getAllExtensions Text
"markdown"


--------------------------------------------------------------------------------
defaultExtensionList :: ExtensionList
defaultExtensionList :: ExtensionList
defaultExtensionList = Extensions -> ExtensionList
ExtensionList (Extensions -> ExtensionList) -> Extensions -> ExtensionList
forall a b. (a -> b) -> a -> b
$
    ReaderOptions -> Extensions
Pandoc.readerExtensions ReaderOptions
forall a. Default a => a
Pandoc.def Extensions -> Extensions -> Extensions
forall a. Monoid a => a -> a -> a
`mappend` [Extension] -> Extensions
Pandoc.extensionsFromList
    [ Extension
Pandoc.Ext_yaml_metadata_block
    , Extension
Pandoc.Ext_table_captions
    , Extension
Pandoc.Ext_simple_tables
    , Extension
Pandoc.Ext_multiline_tables
    , Extension
Pandoc.Ext_grid_tables
    , Extension
Pandoc.Ext_pipe_tables
    , Extension
Pandoc.Ext_raw_html
    , Extension
Pandoc.Ext_tex_math_dollars
    , Extension
Pandoc.Ext_fenced_code_blocks
    , Extension
Pandoc.Ext_fenced_code_attributes
    , Extension
Pandoc.Ext_backtick_code_blocks
    , Extension
Pandoc.Ext_inline_code_attributes
    , Extension
Pandoc.Ext_fancy_lists
    , Extension
Pandoc.Ext_four_space_rule
    , Extension
Pandoc.Ext_definition_lists
    , Extension
Pandoc.Ext_compact_definition_lists
    , Extension
Pandoc.Ext_example_lists
    , Extension
Pandoc.Ext_strikeout
    , Extension
Pandoc.Ext_superscript
    , Extension
Pandoc.Ext_subscript
    , Extension
Pandoc.Ext_shortcut_reference_links
    ]


--------------------------------------------------------------------------------
data ImageSettings = ImageSettings
    { ImageSettings -> Text
isBackend :: !T.Text
    , ImageSettings -> Object
isParams  :: !A.Object
    } deriving (ImageSettings -> ImageSettings -> Bool
(ImageSettings -> ImageSettings -> Bool)
-> (ImageSettings -> ImageSettings -> Bool) -> Eq ImageSettings
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ImageSettings -> ImageSettings -> Bool
== :: ImageSettings -> ImageSettings -> Bool
$c/= :: ImageSettings -> ImageSettings -> Bool
/= :: ImageSettings -> ImageSettings -> Bool
Eq, Int -> ImageSettings -> ShowS
[ImageSettings] -> ShowS
ImageSettings -> String
(Int -> ImageSettings -> ShowS)
-> (ImageSettings -> String)
-> ([ImageSettings] -> ShowS)
-> Show ImageSettings
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ImageSettings -> ShowS
showsPrec :: Int -> ImageSettings -> ShowS
$cshow :: ImageSettings -> String
show :: ImageSettings -> String
$cshowList :: [ImageSettings] -> ShowS
showList :: [ImageSettings] -> ShowS
Show)


--------------------------------------------------------------------------------
instance A.FromJSON ImageSettings where
    parseJSON :: Value -> Parser ImageSettings
parseJSON = String
-> (Object -> Parser ImageSettings)
-> Value
-> Parser ImageSettings
forall a. String -> (Object -> Parser a) -> Value -> Parser a
A.withObject String
"FromJSON ImageSettings" ((Object -> Parser ImageSettings) -> Value -> Parser ImageSettings)
-> (Object -> Parser ImageSettings)
-> Value
-> Parser ImageSettings
forall a b. (a -> b) -> a -> b
$ \Object
o -> do
        t <- Object
o Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
A..: Key
"backend"
        return ImageSettings {isBackend = t, isParams = o}


--------------------------------------------------------------------------------
newtype EvalSettingsMap = EvalSettingsMap (HMS.HashMap (CI T.Text) EvalSettings)
    deriving (EvalSettingsMap -> EvalSettingsMap -> Bool
(EvalSettingsMap -> EvalSettingsMap -> Bool)
-> (EvalSettingsMap -> EvalSettingsMap -> Bool)
-> Eq EvalSettingsMap
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: EvalSettingsMap -> EvalSettingsMap -> Bool
== :: EvalSettingsMap -> EvalSettingsMap -> Bool
$c/= :: EvalSettingsMap -> EvalSettingsMap -> Bool
/= :: EvalSettingsMap -> EvalSettingsMap -> Bool
Eq, Int -> EvalSettingsMap -> ShowS
[EvalSettingsMap] -> ShowS
EvalSettingsMap -> String
(Int -> EvalSettingsMap -> ShowS)
-> (EvalSettingsMap -> String)
-> ([EvalSettingsMap] -> ShowS)
-> Show EvalSettingsMap
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> EvalSettingsMap -> ShowS
showsPrec :: Int -> EvalSettingsMap -> ShowS
$cshow :: EvalSettingsMap -> String
show :: EvalSettingsMap -> String
$cshowList :: [EvalSettingsMap] -> ShowS
showList :: [EvalSettingsMap] -> ShowS
Show, NonEmpty EvalSettingsMap -> EvalSettingsMap
EvalSettingsMap -> EvalSettingsMap -> EvalSettingsMap
(EvalSettingsMap -> EvalSettingsMap -> EvalSettingsMap)
-> (NonEmpty EvalSettingsMap -> EvalSettingsMap)
-> (forall b.
    Integral b =>
    b -> EvalSettingsMap -> EvalSettingsMap)
-> Semigroup EvalSettingsMap
forall b. Integral b => b -> EvalSettingsMap -> EvalSettingsMap
forall a.
(a -> a -> a)
-> (NonEmpty a -> a)
-> (forall b. Integral b => b -> a -> a)
-> Semigroup a
$c<> :: EvalSettingsMap -> EvalSettingsMap -> EvalSettingsMap
<> :: EvalSettingsMap -> EvalSettingsMap -> EvalSettingsMap
$csconcat :: NonEmpty EvalSettingsMap -> EvalSettingsMap
sconcat :: NonEmpty EvalSettingsMap -> EvalSettingsMap
$cstimes :: forall b. Integral b => b -> EvalSettingsMap -> EvalSettingsMap
stimes :: forall b. Integral b => b -> EvalSettingsMap -> EvalSettingsMap
Semigroup)


--------------------------------------------------------------------------------
instance A.FromJSON EvalSettingsMap where
    parseJSON :: Value -> Parser EvalSettingsMap
parseJSON =
        (HashMap Text EvalSettings -> EvalSettingsMap)
-> Parser (HashMap Text EvalSettings) -> Parser EvalSettingsMap
forall a b. (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (HashMap (CI Text) EvalSettings -> EvalSettingsMap
EvalSettingsMap (HashMap (CI Text) EvalSettings -> EvalSettingsMap)
-> (HashMap Text EvalSettings -> HashMap (CI Text) EvalSettings)
-> HashMap Text EvalSettings
-> EvalSettingsMap
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [(CI Text, EvalSettings)] -> HashMap (CI Text) EvalSettings
forall k v. (Eq k, Hashable k) => [(k, v)] -> HashMap k v
HMS.fromList ([(CI Text, EvalSettings)] -> HashMap (CI Text) EvalSettings)
-> (HashMap Text EvalSettings -> [(CI Text, EvalSettings)])
-> HashMap Text EvalSettings
-> HashMap (CI Text) EvalSettings
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((Text, EvalSettings) -> (CI Text, EvalSettings))
-> [(Text, EvalSettings)] -> [(CI Text, EvalSettings)]
forall a b. (a -> b) -> [a] -> [b]
map ((Text -> CI Text)
-> (Text, EvalSettings) -> (CI Text, EvalSettings)
forall a b c. (a -> b) -> (a, c) -> (b, c)
forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first Text -> CI Text
forall s. FoldCase s => s -> CI s
CI.mk) ([(Text, EvalSettings)] -> [(CI Text, EvalSettings)])
-> (HashMap Text EvalSettings -> [(Text, EvalSettings)])
-> HashMap Text EvalSettings
-> [(CI Text, EvalSettings)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. HashMap Text EvalSettings -> [(Text, EvalSettings)]
forall k v. HashMap k v -> [(k, v)]
HMS.toList) (Parser (HashMap Text EvalSettings) -> Parser EvalSettingsMap)
-> (Value -> Parser (HashMap Text EvalSettings))
-> Value
-> Parser EvalSettingsMap
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
        Value -> Parser (HashMap Text EvalSettings)
forall a. FromJSON a => Value -> Parser a
A.parseJSON


--------------------------------------------------------------------------------
data EvalSettingsContainer
    = EvalContainerCode
    | EvalContainerNone
    | EvalContainerInline
    deriving (EvalSettingsContainer -> EvalSettingsContainer -> Bool
(EvalSettingsContainer -> EvalSettingsContainer -> Bool)
-> (EvalSettingsContainer -> EvalSettingsContainer -> Bool)
-> Eq EvalSettingsContainer
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: EvalSettingsContainer -> EvalSettingsContainer -> Bool
== :: EvalSettingsContainer -> EvalSettingsContainer -> Bool
$c/= :: EvalSettingsContainer -> EvalSettingsContainer -> Bool
/= :: EvalSettingsContainer -> EvalSettingsContainer -> Bool
Eq, Int -> EvalSettingsContainer -> ShowS
[EvalSettingsContainer] -> ShowS
EvalSettingsContainer -> String
(Int -> EvalSettingsContainer -> ShowS)
-> (EvalSettingsContainer -> String)
-> ([EvalSettingsContainer] -> ShowS)
-> Show EvalSettingsContainer
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> EvalSettingsContainer -> ShowS
showsPrec :: Int -> EvalSettingsContainer -> ShowS
$cshow :: EvalSettingsContainer -> String
show :: EvalSettingsContainer -> String
$cshowList :: [EvalSettingsContainer] -> ShowS
showList :: [EvalSettingsContainer] -> ShowS
Show)


--------------------------------------------------------------------------------
instance A.FromJSON EvalSettingsContainer where
    parseJSON :: Value -> Parser EvalSettingsContainer
parseJSON = String
-> (Text -> Parser EvalSettingsContainer)
-> Value
-> Parser EvalSettingsContainer
forall a. String -> (Text -> Parser a) -> Value -> Parser a
A.withText String
"FromJSON EvalSettingsContainer" ((Text -> Parser EvalSettingsContainer)
 -> Value -> Parser EvalSettingsContainer)
-> (Text -> Parser EvalSettingsContainer)
-> Value
-> Parser EvalSettingsContainer
forall a b. (a -> b) -> a -> b
$ \Text
t -> case Text
t of
        Text
"code"      -> EvalSettingsContainer -> Parser EvalSettingsContainer
forall a. a -> Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure EvalSettingsContainer
EvalContainerCode
        Text
"none"      -> EvalSettingsContainer -> Parser EvalSettingsContainer
forall a. a -> Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure EvalSettingsContainer
EvalContainerNone
        Text
"inline"    -> EvalSettingsContainer -> Parser EvalSettingsContainer
forall a. a -> Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure EvalSettingsContainer
EvalContainerInline
        -- Deprecated names
        Text
"raw"       -> EvalSettingsContainer -> Parser EvalSettingsContainer
forall a. a -> Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure EvalSettingsContainer
EvalContainerNone
        Text
"rawInline" -> EvalSettingsContainer -> Parser EvalSettingsContainer
forall a. a -> Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure EvalSettingsContainer
EvalContainerInline
        Text
_           -> String -> Parser EvalSettingsContainer
forall a. String -> Parser a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String -> Parser EvalSettingsContainer)
-> String -> Parser EvalSettingsContainer
forall a b. (a -> b) -> a -> b
$ String
"unknown container: " String -> ShowS
forall a. Semigroup a => a -> a -> a
<> Text -> String
forall a. Show a => a -> String
show Text
t


--------------------------------------------------------------------------------
data EvalSettings = EvalSettings
    { EvalSettings -> Text
evalCommand   :: !T.Text
    , EvalSettings -> Bool
evalReplace   :: !Bool
    , EvalSettings -> Bool
evalReveal    :: !Bool
    , EvalSettings -> EvalSettingsContainer
evalContainer :: !EvalSettingsContainer
    , EvalSettings -> Bool
evalStderr    :: !Bool
    , EvalSettings -> Maybe (CI Text)
evalSyntax    :: !(Maybe (CI T.Text))
    } deriving (EvalSettings -> EvalSettings -> Bool
(EvalSettings -> EvalSettings -> Bool)
-> (EvalSettings -> EvalSettings -> Bool) -> Eq EvalSettings
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: EvalSettings -> EvalSettings -> Bool
== :: EvalSettings -> EvalSettings -> Bool
$c/= :: EvalSettings -> EvalSettings -> Bool
/= :: EvalSettings -> EvalSettings -> Bool
Eq, Int -> EvalSettings -> ShowS
[EvalSettings] -> ShowS
EvalSettings -> String
(Int -> EvalSettings -> ShowS)
-> (EvalSettings -> String)
-> ([EvalSettings] -> ShowS)
-> Show EvalSettings
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> EvalSettings -> ShowS
showsPrec :: Int -> EvalSettings -> ShowS
$cshow :: EvalSettings -> String
show :: EvalSettings -> String
$cshowList :: [EvalSettings] -> ShowS
showList :: [EvalSettings] -> ShowS
Show)


--------------------------------------------------------------------------------
instance A.FromJSON EvalSettings where
    parseJSON :: Value -> Parser EvalSettings
parseJSON = String
-> (Object -> Parser EvalSettings) -> Value -> Parser EvalSettings
forall a. String -> (Object -> Parser a) -> Value -> Parser a
A.withObject String
"FromJSON EvalSettings" ((Object -> Parser EvalSettings) -> Value -> Parser EvalSettings)
-> (Object -> Parser EvalSettings) -> Value -> Parser EvalSettings
forall a b. (a -> b) -> a -> b
$ \Object
o -> Text
-> Bool
-> Bool
-> EvalSettingsContainer
-> Bool
-> Maybe (CI Text)
-> EvalSettings
EvalSettings
        (Text
 -> Bool
 -> Bool
 -> EvalSettingsContainer
 -> Bool
 -> Maybe (CI Text)
 -> EvalSettings)
-> Parser Text
-> Parser
     (Bool
      -> Bool
      -> EvalSettingsContainer
      -> Bool
      -> Maybe (CI Text)
      -> EvalSettings)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
A..:  Key
"command"
        Parser
  (Bool
   -> Bool
   -> EvalSettingsContainer
   -> Bool
   -> Maybe (CI Text)
   -> EvalSettings)
-> Parser Bool
-> Parser
     (Bool
      -> EvalSettingsContainer
      -> Bool
      -> Maybe (CI Text)
      -> EvalSettings)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser (Maybe Bool)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
A..:? Key
"replace"  Parser (Maybe Bool) -> Bool -> Parser Bool
forall a. Parser (Maybe a) -> a -> Parser a
A..!= Bool
False
        Parser
  (Bool
   -> EvalSettingsContainer
   -> Bool
   -> Maybe (CI Text)
   -> EvalSettings)
-> Parser Bool
-> Parser
     (EvalSettingsContainer -> Bool -> Maybe (CI Text) -> EvalSettings)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Key -> Key -> Bool -> Object -> Parser Bool
forall {b}. FromJSON b => Key -> Key -> b -> Object -> Parser b
deprecated Key
"fragment" Key
"reveal" Bool
True Object
o
        Parser
  (EvalSettingsContainer -> Bool -> Maybe (CI Text) -> EvalSettings)
-> Parser EvalSettingsContainer
-> Parser (Bool -> Maybe (CI Text) -> EvalSettings)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Key
-> Key
-> EvalSettingsContainer
-> Object
-> Parser EvalSettingsContainer
forall {b}. FromJSON b => Key -> Key -> b -> Object -> Parser b
deprecated Key
"wrap" Key
"container" EvalSettingsContainer
EvalContainerCode Object
o
        Parser (Bool -> Maybe (CI Text) -> EvalSettings)
-> Parser Bool -> Parser (Maybe (CI Text) -> EvalSettings)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser (Maybe Bool)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
A..:? Key
"stderr" Parser (Maybe Bool) -> Bool -> Parser Bool
forall a. Parser (Maybe a) -> a -> Parser a
A..!= Bool
True
        Parser (Maybe (CI Text) -> EvalSettings)
-> Parser (Maybe (CI Text)) -> Parser EvalSettings
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ((Text -> CI Text) -> Maybe Text -> Maybe (CI Text)
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Text -> CI Text
forall s. FoldCase s => s -> CI s
CI.mk (Maybe Text -> Maybe (CI Text))
-> Parser (Maybe Text) -> Parser (Maybe (CI Text))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o Object -> Key -> Parser (Maybe Text)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
A..:? Key
"syntax")
      where
        deprecated :: Key -> Key -> b -> Object -> Parser b
deprecated Key
old Key
new b
def Object
obj = do
            mo <- Object
obj Object -> Key -> Parser (Maybe b)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
A..:? Key
old
            mn <- obj A..:? new
            case (mo, mn) of
                (Just b
_, Just b
_)   -> String -> Parser b
forall a. String -> Parser a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String -> Parser b) -> String -> Parser b
forall a b. (a -> b) -> a -> b
$
                    Key -> String
forall a. Show a => a -> String
show Key
old String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
" (deprecated) and " String -> ShowS
forall a. [a] -> [a] -> [a]
++ Key -> String
forall a. Show a => a -> String
show Key
new String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
" " String -> ShowS
forall a. [a] -> [a] -> [a]
++
                    String
"are both specified, please remove " String -> ShowS
forall a. [a] -> [a] -> [a]
++ Key -> String
forall a. Show a => a -> String
show Key
old
                (Just b
o, Maybe b
Nothing)  -> b -> Parser b
forall a. a -> Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure b
o
                (Maybe b
Nothing, Just b
n)  -> b -> Parser b
forall a. a -> Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure b
n
                (Maybe b
Nothing, Maybe b
Nothing) -> b -> Parser b
forall a. a -> Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure b
def


--------------------------------------------------------------------------------
data SpeakerNotesSettings = SpeakerNotesSettings
    { SpeakerNotesSettings -> String
snsFile :: !FilePath
    } deriving (SpeakerNotesSettings -> SpeakerNotesSettings -> Bool
(SpeakerNotesSettings -> SpeakerNotesSettings -> Bool)
-> (SpeakerNotesSettings -> SpeakerNotesSettings -> Bool)
-> Eq SpeakerNotesSettings
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SpeakerNotesSettings -> SpeakerNotesSettings -> Bool
== :: SpeakerNotesSettings -> SpeakerNotesSettings -> Bool
$c/= :: SpeakerNotesSettings -> SpeakerNotesSettings -> Bool
/= :: SpeakerNotesSettings -> SpeakerNotesSettings -> Bool
Eq, Int -> SpeakerNotesSettings -> ShowS
[SpeakerNotesSettings] -> ShowS
SpeakerNotesSettings -> String
(Int -> SpeakerNotesSettings -> ShowS)
-> (SpeakerNotesSettings -> String)
-> ([SpeakerNotesSettings] -> ShowS)
-> Show SpeakerNotesSettings
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SpeakerNotesSettings -> ShowS
showsPrec :: Int -> SpeakerNotesSettings -> ShowS
$cshow :: SpeakerNotesSettings -> String
show :: SpeakerNotesSettings -> String
$cshowList :: [SpeakerNotesSettings] -> ShowS
showList :: [SpeakerNotesSettings] -> ShowS
Show)


--------------------------------------------------------------------------------
data TransitionSettings = TransitionSettings
    { TransitionSettings -> Text
tsType   :: !T.Text
    , TransitionSettings -> Object
tsParams :: !A.Object
    } deriving (TransitionSettings -> TransitionSettings -> Bool
(TransitionSettings -> TransitionSettings -> Bool)
-> (TransitionSettings -> TransitionSettings -> Bool)
-> Eq TransitionSettings
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TransitionSettings -> TransitionSettings -> Bool
== :: TransitionSettings -> TransitionSettings -> Bool
$c/= :: TransitionSettings -> TransitionSettings -> Bool
/= :: TransitionSettings -> TransitionSettings -> Bool
Eq, Int -> TransitionSettings -> ShowS
[TransitionSettings] -> ShowS
TransitionSettings -> String
(Int -> TransitionSettings -> ShowS)
-> (TransitionSettings -> String)
-> ([TransitionSettings] -> ShowS)
-> Show TransitionSettings
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> TransitionSettings -> ShowS
showsPrec :: Int -> TransitionSettings -> ShowS
$cshow :: TransitionSettings -> String
show :: TransitionSettings -> String
$cshowList :: [TransitionSettings] -> ShowS
showList :: [TransitionSettings] -> ShowS
Show)


--------------------------------------------------------------------------------
instance A.FromJSON TransitionSettings where
    parseJSON :: Value -> Parser TransitionSettings
parseJSON = String
-> (Object -> Parser TransitionSettings)
-> Value
-> Parser TransitionSettings
forall a. String -> (Object -> Parser a) -> Value -> Parser a
A.withObject String
"FromJSON TransitionSettings" ((Object -> Parser TransitionSettings)
 -> Value -> Parser TransitionSettings)
-> (Object -> Parser TransitionSettings)
-> Value
-> Parser TransitionSettings
forall a b. (a -> b) -> a -> b
$ \Object
o ->
        Text -> Object -> TransitionSettings
TransitionSettings (Text -> Object -> TransitionSettings)
-> Parser Text -> Parser (Object -> TransitionSettings)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
A..: Key
"type" Parser (Object -> TransitionSettings)
-> Parser Object -> Parser TransitionSettings
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object -> Parser Object
forall a. a -> Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Object
o


--------------------------------------------------------------------------------
data LinkSettings = LinkSettings
    { LinkSettings -> Maybe Bool
lsOSC8 :: !(Maybe Bool)
    } deriving (LinkSettings -> LinkSettings -> Bool
(LinkSettings -> LinkSettings -> Bool)
-> (LinkSettings -> LinkSettings -> Bool) -> Eq LinkSettings
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: LinkSettings -> LinkSettings -> Bool
== :: LinkSettings -> LinkSettings -> Bool
$c/= :: LinkSettings -> LinkSettings -> Bool
/= :: LinkSettings -> LinkSettings -> Bool
Eq, Int -> LinkSettings -> ShowS
[LinkSettings] -> ShowS
LinkSettings -> String
(Int -> LinkSettings -> ShowS)
-> (LinkSettings -> String)
-> ([LinkSettings] -> ShowS)
-> Show LinkSettings
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> LinkSettings -> ShowS
showsPrec :: Int -> LinkSettings -> ShowS
$cshow :: LinkSettings -> String
show :: LinkSettings -> String
$cshowList :: [LinkSettings] -> ShowS
showList :: [LinkSettings] -> ShowS
Show)


--------------------------------------------------------------------------------
instance Semigroup LinkSettings where
    LinkSettings
l <> :: LinkSettings -> LinkSettings -> LinkSettings
<> LinkSettings
r = LinkSettings
        { lsOSC8 :: Maybe Bool
lsOSC8 = (Maybe Bool -> Maybe Bool -> Maybe Bool)
-> (LinkSettings -> Maybe Bool)
-> LinkSettings
-> LinkSettings
-> Maybe Bool
forall b c a. (b -> b -> c) -> (a -> b) -> a -> a -> c
on Maybe Bool -> Maybe Bool -> Maybe Bool
forall a. Maybe a -> Maybe a -> Maybe a
forall (m :: * -> *) a. MonadPlus m => m a -> m a -> m a
mplus LinkSettings -> Maybe Bool
lsOSC8 LinkSettings
l LinkSettings
r
        }


--------------------------------------------------------------------------------
instance A.FromJSON LinkSettings where
    parseJSON :: Value -> Parser LinkSettings
parseJSON = String
-> (Object -> Parser LinkSettings) -> Value -> Parser LinkSettings
forall a. String -> (Object -> Parser a) -> Value -> Parser a
A.withObject String
"FromJSON LinkSettings" ((Object -> Parser LinkSettings) -> Value -> Parser LinkSettings)
-> (Object -> Parser LinkSettings) -> Value -> Parser LinkSettings
forall a b. (a -> b) -> a -> b
$ \Object
o ->
        Maybe Bool -> LinkSettings
LinkSettings (Maybe Bool -> LinkSettings)
-> Parser (Maybe Bool) -> Parser LinkSettings
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o Object -> Key -> Parser (Maybe Bool)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
A..:? Key
"osc8"


--------------------------------------------------------------------------------
$(A.deriveFromJSON A.dropPrefixOptions ''MarginSettings)
$(A.deriveFromJSON A.dropPrefixOptions ''SpeakerNotesSettings)
$(A.deriveFromJSON A.dropPrefixOptions ''PresentationSettings)


--------------------------------------------------------------------------------
data Setting where
    Setting :: String -> (PresentationSettings -> Maybe a) -> Setting


--------------------------------------------------------------------------------
unsupportedSlideSettings :: [Setting]
unsupportedSlideSettings :: [Setting]
unsupportedSlideSettings =
    [ String -> (PresentationSettings -> Maybe Bool) -> Setting
forall a. String -> (PresentationSettings -> Maybe a) -> Setting
Setting String
"incrementalLists" PresentationSettings -> Maybe Bool
psIncrementalLists
    , String
-> (PresentationSettings -> Maybe (FlexibleNum Int)) -> Setting
forall a. String -> (PresentationSettings -> Maybe a) -> Setting
Setting String
"autoAdvanceDelay" PresentationSettings -> Maybe (FlexibleNum Int)
psAutoAdvanceDelay
    , String -> (PresentationSettings -> Maybe Int) -> Setting
forall a. String -> (PresentationSettings -> Maybe a) -> Setting
Setting String
"slideLevel"       PresentationSettings -> Maybe Int
psSlideLevel
    , String -> (PresentationSettings -> Maybe ExtensionList) -> Setting
forall a. String -> (PresentationSettings -> Maybe a) -> Setting
Setting String
"pandocExtensions" PresentationSettings -> Maybe ExtensionList
psPandocExtensions
    , String -> (PresentationSettings -> Maybe ImageSettings) -> Setting
forall a. String -> (PresentationSettings -> Maybe a) -> Setting
Setting String
"images"           PresentationSettings -> Maybe ImageSettings
psImages
    , String
-> (PresentationSettings -> Maybe EvalSettingsMap) -> Setting
forall a. String -> (PresentationSettings -> Maybe a) -> Setting
Setting String
"eval"             PresentationSettings -> Maybe EvalSettingsMap
psEval
    , String
-> (PresentationSettings -> Maybe SpeakerNotesSettings) -> Setting
forall a. String -> (PresentationSettings -> Maybe a) -> Setting
Setting String
"speakerNotes"     PresentationSettings -> Maybe SpeakerNotesSettings
psSpeakerNotes
    ]


--------------------------------------------------------------------------------
parseSlideSettings :: PresentationSettings -> Either String PresentationSettings
parseSlideSettings :: PresentationSettings -> Either String PresentationSettings
parseSlideSettings PresentationSettings
settings = do
    Bool -> Either String () -> Either String ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
unless ([String] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [String]
unsupported) (Either String () -> Either String ())
-> Either String () -> Either String ()
forall a b. (a -> b) -> a -> b
$ String -> Either String ()
forall a b. a -> Either a b
Left (String -> Either String ()) -> String -> Either String ()
forall a b. (a -> b) -> a -> b
$
        String
"the following settings are not supported in slide config blocks: " String -> ShowS
forall a. [a] -> [a] -> [a]
++
        String -> [String] -> String
forall a. [a] -> [[a]] -> [a]
intercalate String
", " [String]
unsupported
    PresentationSettings -> Either String PresentationSettings
forall a. a -> Either String a
forall (f :: * -> *) a. Applicative f => a -> f a
pure PresentationSettings
settings
  where
    unsupported :: [String]
unsupported = do
        setting <- [Setting]
unsupportedSlideSettings
        case setting of
            Setting String
name PresentationSettings -> Maybe a
f | Just a
_ <- PresentationSettings -> Maybe a
f PresentationSettings
settings -> [String
name]
            Setting String
_    PresentationSettings -> Maybe a
_                        -> []