{-# 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
= 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