{-# LANGUAGE FlexibleInstances #-}

module Text.Pandoc.Legacy.Builder
  ( module Text.Pandoc.Legacy.Definition
  , B.Many(..)
  , B.Inlines
  , B.Blocks
  , (<>)
  , B.singleton
  , B.toList
  , B.fromList
  , B.isNull
  , B.doc
  , ToMetaValue(..)
  , HasMeta(..)
  , B.setTitle
  , B.setAuthors
  , B.setDate
  , text
  , str
  , B.emph
  , B.strong
  , B.strikeout
  , B.superscript
  , B.subscript
  , B.smallcaps
  , B.singleQuoted
  , B.doubleQuoted
  , B.cite
  , codeWith
  , code
  , B.space
  , B.softbreak
  , B.linebreak
  , math
  , displayMath
  , rawInline
  , link
  , linkWith
  , image
  , imageWith
  , B.note
  , spanWith
  , B.trimInlines
  , B.para
  , B.plain
  , B.lineBlock
  , codeBlockWith
  , codeBlock
  , rawBlock
  , B.blockQuote
  , B.bulletList
  , B.orderedListWith
  , B.orderedList
  , B.definitionList
  , B.header
  , headerWith
  , B.horizontalRule
  , B.table
  , B.simpleTable
  , divWith
  ) where

import qualified Data.Map as M
import qualified Data.Text as T
import qualified Text.Pandoc.Builder as B
import Text.Pandoc.Legacy.Definition
import Data.Semigroup (Semigroup(..))

fromLegacyAttr :: Attr -> B.Attr
fromLegacyAttr :: Attr -> Attr
fromLegacyAttr (a :: String
a, b :: [String]
b, c :: [(String, String)]
c) = (String -> Text
T.pack String
a, (String -> Text) -> [String] -> [Text]
forall a b. (a -> b) -> [a] -> [b]
map String -> Text
T.pack [String]
b, ((String, String) -> (Text, Text))
-> [(String, String)] -> [(Text, Text)]
forall a b. (a -> b) -> [a] -> [b]
map (String, String) -> (Text, Text)
pack2 [(String, String)]
c)
  where
    pack2 :: (String, String) -> (Text, Text)
pack2 (x :: String
x, y :: String
y) = (String -> Text
T.pack String
x, String -> Text
T.pack String
y)

class ToMetaValue a where
  toMetaValue :: a -> B.MetaValue

instance ToMetaValue B.MetaValue where
  toMetaValue :: MetaValue -> MetaValue
toMetaValue = MetaValue -> MetaValue
forall a. a -> a
id

instance ToMetaValue B.Blocks where
  toMetaValue :: Blocks -> MetaValue
toMetaValue = [Block] -> MetaValue
B.MetaBlocks ([Block] -> MetaValue)
-> (Blocks -> [Block]) -> Blocks -> MetaValue
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Blocks -> [Block]
forall a. Many a -> [a]
B.toList

instance ToMetaValue B.Inlines where
  toMetaValue :: Inlines -> MetaValue
toMetaValue = [Inline] -> MetaValue
MetaInlines ([Inline] -> MetaValue)
-> (Inlines -> [Inline]) -> Inlines -> MetaValue
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Inlines -> [Inline]
forall a. Many a -> [a]
B.toList

instance ToMetaValue Bool where
  toMetaValue :: Bool -> MetaValue
toMetaValue = Bool -> MetaValue
MetaBool

instance {-# OVERLAPPING #-} ToMetaValue String where
  toMetaValue :: String -> MetaValue
toMetaValue = String -> MetaValue
MetaString

instance ToMetaValue a => ToMetaValue [a] where
  toMetaValue :: [a] -> MetaValue
toMetaValue = [MetaValue] -> MetaValue
MetaList ([MetaValue] -> MetaValue)
-> ([a] -> [MetaValue]) -> [a] -> MetaValue
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> MetaValue) -> [a] -> [MetaValue]
forall a b. (a -> b) -> [a] -> [b]
map a -> MetaValue
forall a. ToMetaValue a => a -> MetaValue
toMetaValue

instance ToMetaValue a => ToMetaValue (M.Map String a) where
  toMetaValue :: Map String a -> MetaValue
toMetaValue = Map String MetaValue -> MetaValue
MetaMap (Map String MetaValue -> MetaValue)
-> (Map String a -> Map String MetaValue)
-> Map String a
-> MetaValue
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> MetaValue) -> Map String a -> Map String MetaValue
forall a b k. (a -> b) -> Map k a -> Map k b
M.map a -> MetaValue
forall a. ToMetaValue a => a -> MetaValue
toMetaValue

class HasMeta a where
  setMeta :: ToMetaValue b => String -> b -> a -> a
  deleteMeta :: String -> a -> a

instance HasMeta Meta where
  setMeta :: String -> b -> Meta -> Meta
setMeta key :: String
key val :: b
val (B.Meta ms :: Map Text MetaValue
ms) = Map Text MetaValue -> Meta
B.Meta (Map Text MetaValue -> Meta) -> Map Text MetaValue -> Meta
forall a b. (a -> b) -> a -> b
$ Text -> MetaValue -> Map Text MetaValue -> Map Text MetaValue
forall k a. Ord k => k -> a -> Map k a -> Map k a
M.insert (String -> Text
T.pack String
key) (b -> MetaValue
forall a. ToMetaValue a => a -> MetaValue
toMetaValue b
val) Map Text MetaValue
ms
  deleteMeta :: String -> Meta -> Meta
deleteMeta key :: String
key (B.Meta ms :: Map Text MetaValue
ms) = Map Text MetaValue -> Meta
B.Meta (Map Text MetaValue -> Meta) -> Map Text MetaValue -> Meta
forall a b. (a -> b) -> a -> b
$ Text -> Map Text MetaValue -> Map Text MetaValue
forall k a. Ord k => k -> Map k a -> Map k a
M.delete (String -> Text
T.pack String
key) Map Text MetaValue
ms

instance HasMeta Pandoc where
  setMeta :: String -> b -> Pandoc -> Pandoc
setMeta key :: String
key val :: b
val (Pandoc (B.Meta ms :: Map Text MetaValue
ms) bs :: [Block]
bs) =
    Meta -> [Block] -> Pandoc
Pandoc (Map Text MetaValue -> Meta
B.Meta (Map Text MetaValue -> Meta) -> Map Text MetaValue -> Meta
forall a b. (a -> b) -> a -> b
$ Text -> MetaValue -> Map Text MetaValue -> Map Text MetaValue
forall k a. Ord k => k -> a -> Map k a -> Map k a
M.insert (String -> Text
T.pack String
key) (b -> MetaValue
forall a. ToMetaValue a => a -> MetaValue
toMetaValue b
val) Map Text MetaValue
ms) [Block]
bs
  deleteMeta :: String -> Pandoc -> Pandoc
deleteMeta key :: String
key (Pandoc (B.Meta ms :: Map Text MetaValue
ms) bs :: [Block]
bs) =
    Meta -> [Block] -> Pandoc
Pandoc (Map Text MetaValue -> Meta
B.Meta (Map Text MetaValue -> Meta) -> Map Text MetaValue -> Meta
forall a b. (a -> b) -> a -> b
$ Text -> Map Text MetaValue -> Map Text MetaValue
forall k a. Ord k => k -> Map k a -> Map k a
M.delete (String -> Text
T.pack String
key) Map Text MetaValue
ms) [Block]
bs

text :: String -> B.Inlines
text :: String -> Inlines
text = Text -> Inlines
B.text (Text -> Inlines) -> (String -> Text) -> String -> Inlines
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Text
T.pack

str :: String -> B.Inlines
str :: String -> Inlines
str = Text -> Inlines
B.str (Text -> Inlines) -> (String -> Text) -> String -> Inlines
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Text
T.pack

codeWith :: Attr -> String -> B.Inlines
codeWith :: Attr -> String -> Inlines
codeWith a :: Attr
a = Attr -> Text -> Inlines
B.codeWith (Attr -> Attr
fromLegacyAttr Attr
a) (Text -> Inlines) -> (String -> Text) -> String -> Inlines
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Text
T.pack

code :: String -> B.Inlines
code :: String -> Inlines
code = Text -> Inlines
B.code (Text -> Inlines) -> (String -> Text) -> String -> Inlines
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Text
T.pack

math :: String -> B.Inlines
math :: String -> Inlines
math = Text -> Inlines
B.math (Text -> Inlines) -> (String -> Text) -> String -> Inlines
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Text
T.pack

displayMath :: String -> B.Inlines
displayMath :: String -> Inlines
displayMath = Text -> Inlines
B.displayMath (Text -> Inlines) -> (String -> Text) -> String -> Inlines
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Text
T.pack

rawInline :: String -> String -> B.Inlines
rawInline :: String -> String -> Inlines
rawInline s :: String
s = Text -> Text -> Inlines
B.rawInline (String -> Text
T.pack String
s) (Text -> Inlines) -> (String -> Text) -> String -> Inlines
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Text
T.pack

link :: String -> String -> B.Inlines -> B.Inlines
link :: String -> String -> Inlines -> Inlines
link s :: String
s = Text -> Text -> Inlines -> Inlines
B.link (String -> Text
T.pack String
s) (Text -> Inlines -> Inlines)
-> (String -> Text) -> String -> Inlines -> Inlines
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Text
T.pack

linkWith :: Attr -> String -> String -> B.Inlines -> B.Inlines
linkWith :: Attr -> String -> String -> Inlines -> Inlines
linkWith a :: Attr
a s :: String
s = Attr -> Text -> Text -> Inlines -> Inlines
B.linkWith (Attr -> Attr
fromLegacyAttr Attr
a) (String -> Text
T.pack String
s) (Text -> Inlines -> Inlines)
-> (String -> Text) -> String -> Inlines -> Inlines
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Text
T.pack

image :: String -> String -> B.Inlines -> B.Inlines
image :: String -> String -> Inlines -> Inlines
image s :: String
s = Text -> Text -> Inlines -> Inlines
B.image (String -> Text
T.pack String
s) (Text -> Inlines -> Inlines)
-> (String -> Text) -> String -> Inlines -> Inlines
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Text
T.pack

imageWith :: Attr -> String -> String -> B.Inlines -> B.Inlines
imageWith :: Attr -> String -> String -> Inlines -> Inlines
imageWith a :: Attr
a s :: String
s = Attr -> Text -> Text -> Inlines -> Inlines
B.imageWith (Attr -> Attr
fromLegacyAttr Attr
a) (String -> Text
T.pack String
s) (Text -> Inlines -> Inlines)
-> (String -> Text) -> String -> Inlines -> Inlines
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Text
T.pack

spanWith :: Attr -> B.Inlines -> B.Inlines
spanWith :: Attr -> Inlines -> Inlines
spanWith = Attr -> Inlines -> Inlines
B.spanWith (Attr -> Inlines -> Inlines)
-> (Attr -> Attr) -> Attr -> Inlines -> Inlines
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Attr -> Attr
fromLegacyAttr

codeBlockWith :: Attr -> String -> B.Blocks
codeBlockWith :: Attr -> String -> Blocks
codeBlockWith a :: Attr
a = Attr -> Text -> Blocks
B.codeBlockWith (Attr -> Attr
fromLegacyAttr Attr
a) (Text -> Blocks) -> (String -> Text) -> String -> Blocks
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Text
T.pack

codeBlock :: String -> B.Blocks
codeBlock :: String -> Blocks
codeBlock = Text -> Blocks
B.codeBlock (Text -> Blocks) -> (String -> Text) -> String -> Blocks
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Text
T.pack

rawBlock :: String -> String -> B.Blocks
rawBlock :: String -> String -> Blocks
rawBlock s :: String
s = Text -> Text -> Blocks
B.rawBlock (String -> Text
T.pack String
s) (Text -> Blocks) -> (String -> Text) -> String -> Blocks
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Text
T.pack

headerWith :: Attr -> Int -> B.Inlines -> B.Blocks
headerWith :: Attr -> Int -> Inlines -> Blocks
headerWith = Attr -> Int -> Inlines -> Blocks
B.headerWith (Attr -> Int -> Inlines -> Blocks)
-> (Attr -> Attr) -> Attr -> Int -> Inlines -> Blocks
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Attr -> Attr
fromLegacyAttr

divWith :: Attr -> B.Blocks -> B.Blocks
divWith :: Attr -> Blocks -> Blocks
divWith = Attr -> Blocks -> Blocks
B.divWith (Attr -> Blocks -> Blocks)
-> (Attr -> Attr) -> Attr -> Blocks -> Blocks
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Attr -> Attr
fromLegacyAttr