aboutsummaryrefslogtreecommitdiff
path: root/src/Text/Pandoc/Lua/StackInstances.hs
blob: 531261099f0d6b8174980ce94cd9144ec27a6400 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
{-
Copyright © 2012-2018 John MacFarlane <jgm@berkeley.edu>
            2017-2018 Albert Krewinkel <tarleb+pandoc@moltkeplatz.de>

This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE LambdaCase        #-}
{-# OPTIONS_GHC -fno-warn-orphans #-}
{- |
   Module      : Text.Pandoc.Lua.StackInstances
   Copyright   : © 2012-2018 John MacFarlane
                 © 2017-2018 Albert Krewinkel
   License     : GNU GPL, version 2 or above

   Maintainer  : Albert Krewinkel <tarleb+pandoc@moltkeplatz.de>
   Stability   : alpha

StackValue instances for pandoc types.
-}
module Text.Pandoc.Lua.StackInstances () where

import Control.Applicative ((<|>))
import Control.Monad (when)
import Foreign.Lua (FromLuaStack (peek), Lua, LuaInteger, LuaNumber, StackIndex,
                    ToLuaStack (push), Type (..), throwLuaError, tryLua)
import Text.Pandoc.Definition
import Text.Pandoc.Lua.Util (adjustIndexBy, getTable, pushViaConstructor)
import Text.Pandoc.Shared (Element (Blk, Sec), safeRead)

import qualified Foreign.Lua as Lua
import qualified Text.Pandoc.Lua.Util as LuaUtil

instance ToLuaStack Pandoc where
  push (Pandoc meta blocks) =
    pushViaConstructor "Pandoc" blocks meta

instance FromLuaStack Pandoc where
  peek idx = do
    blocks <- getTable idx "blocks"
    meta   <- getTable idx "meta"
    return $ Pandoc meta blocks

instance ToLuaStack Meta where
  push (Meta mmap) =
    pushViaConstructor "Meta" mmap
instance FromLuaStack Meta where
  peek idx = Meta <$> peek idx

instance ToLuaStack MetaValue where
  push = pushMetaValue
instance FromLuaStack MetaValue where
  peek = peekMetaValue

instance ToLuaStack Block where
  push = pushBlock

instance FromLuaStack Block where
  peek = peekBlock

-- Inline
instance ToLuaStack Inline where
  push = pushInline

instance FromLuaStack Inline where
  peek = peekInline

-- Citation
instance ToLuaStack Citation where
  push (Citation cid prefix suffix mode noteNum hash) =
    pushViaConstructor "Citation" cid mode prefix suffix noteNum hash

instance FromLuaStack Citation where
  peek idx = do
    id' <- getTable idx "id"
    prefix <- getTable idx "prefix"
    suffix <- getTable idx "suffix"
    mode <- getTable idx "mode"
    num <- getTable idx "note_num"
    hash <- getTable idx "hash"
    return $ Citation id' prefix suffix mode num hash

instance ToLuaStack Alignment where
  push = push . show
instance FromLuaStack Alignment where
  peek idx = safeRead' =<< peek idx

instance ToLuaStack CitationMode where
  push = push . show
instance FromLuaStack CitationMode where
  peek idx = safeRead' =<< peek idx

instance ToLuaStack Format where
  push (Format f) = push f
instance FromLuaStack Format where
  peek idx = Format <$> peek idx

instance ToLuaStack ListNumberDelim where
  push = push . show
instance FromLuaStack ListNumberDelim where
  peek idx = safeRead' =<< peek idx

instance ToLuaStack ListNumberStyle where
  push = push . show
instance FromLuaStack ListNumberStyle where
  peek idx = safeRead' =<< peek idx

instance ToLuaStack MathType where
  push = push . show
instance FromLuaStack MathType where
  peek idx = safeRead' =<< peek idx

instance ToLuaStack QuoteType where
  push = push . show
instance FromLuaStack QuoteType where
  peek idx = safeRead' =<< peek idx

instance ToLuaStack Double where
  push = push . (realToFrac :: Double -> LuaNumber)
instance FromLuaStack Double where
  peek = fmap (realToFrac :: LuaNumber -> Double) . peek

instance ToLuaStack Int where
  push = push . (fromIntegral :: Int -> LuaInteger)
instance FromLuaStack Int where
  peek = fmap (fromIntegral :: LuaInteger-> Int) . peek

safeRead' :: Read a => String -> Lua a
safeRead' s = case safeRead s of
  Nothing -> throwLuaError ("Could not read: " ++ s)
  Just x  -> return x

-- | Push an meta value element to the top of the lua stack.
pushMetaValue :: MetaValue -> Lua ()
pushMetaValue = \case
  MetaBlocks blcks  -> pushViaConstructor "MetaBlocks" blcks
  MetaBool bool     -> push bool
  MetaInlines inlns -> pushViaConstructor "MetaInlines" inlns
  MetaList metalist -> pushViaConstructor "MetaList" metalist
  MetaMap metamap   -> pushViaConstructor "MetaMap" metamap
  MetaString str    -> push str

-- | Interpret the value at the given stack index as meta value.
peekMetaValue :: StackIndex -> Lua MetaValue
peekMetaValue idx = do
  -- Get the contents of an AST element.
  let elementContent :: FromLuaStack a => Lua a
      elementContent = peek idx
  luatype <- Lua.ltype idx
  case luatype of
    TypeBoolean -> MetaBool <$> peek idx
    TypeString  -> MetaString <$> peek idx
    TypeTable   -> do
      tag <- tryLua $ getTag idx
      case tag of
        Right "MetaBlocks"  -> MetaBlocks  <$> elementContent
        Right "MetaBool"    -> MetaBool    <$> elementContent
        Right "MetaMap"     -> MetaMap     <$> elementContent
        Right "MetaInlines" -> MetaInlines <$> elementContent
        Right "MetaList"    -> MetaList    <$> elementContent
        Right "MetaString"  -> MetaString  <$> elementContent
        Right t             -> throwLuaError ("Unknown meta tag: " ++ t)
        Left _ -> do
          -- no meta value tag given, try to guess.
          len <- Lua.rawlen idx
          if len <= 0
            then MetaMap <$> peek idx
            else  (MetaInlines <$> peek idx)
                  <|> (MetaBlocks <$> peek idx)
                  <|> (MetaList <$> peek idx)
    _        -> throwLuaError "could not get meta value"

-- | Push an block element to the top of the lua stack.
pushBlock :: Block -> Lua ()
pushBlock = \case
  BlockQuote blcks         -> pushViaConstructor "BlockQuote" blcks
  BulletList items         -> pushViaConstructor "BulletList" items
  CodeBlock attr code      -> pushViaConstructor "CodeBlock" code (LuaAttr attr)
  DefinitionList items     -> pushViaConstructor "DefinitionList" items
  Div attr blcks           -> pushViaConstructor "Div" blcks (LuaAttr attr)
  Header lvl attr inlns    -> pushViaConstructor "Header" lvl inlns (LuaAttr attr)
  HorizontalRule           -> pushViaConstructor "HorizontalRule"
  LineBlock blcks          -> pushViaConstructor "LineBlock" blcks
  OrderedList lstAttr list -> pushViaConstructor "OrderedList" list lstAttr
  Null                     -> pushViaConstructor "Null"
  Para blcks               -> pushViaConstructor "Para" blcks
  Plain blcks              -> pushViaConstructor "Plain" blcks
  RawBlock f cs            -> pushViaConstructor "RawBlock" f cs
  Table capt aligns widths headers rows ->
    pushViaConstructor "Table" capt aligns widths headers rows

-- | Return the value at the given index as block if possible.
peekBlock :: StackIndex -> Lua Block
peekBlock idx = do
  tag <- getTag idx
  case tag of
      "BlockQuote"     -> BlockQuote <$> elementContent
      "BulletList"     -> BulletList <$> elementContent
      "CodeBlock"      -> withAttr CodeBlock <$> elementContent
      "DefinitionList" -> DefinitionList <$> elementContent
      "Div"            -> withAttr Div <$> elementContent
      "Header"         -> (\(lvl, LuaAttr attr, lst) -> Header lvl attr lst)
                          <$> elementContent
      "HorizontalRule" -> return HorizontalRule
      "LineBlock"      -> LineBlock <$> elementContent
      "OrderedList"    -> uncurry OrderedList <$> elementContent
      "Null"           -> return Null
      "Para"           -> Para <$> elementContent
      "Plain"          -> Plain <$> elementContent
      "RawBlock"       -> uncurry RawBlock <$> elementContent
      "Table"          -> (\(capt, aligns, widths, headers, body) ->
                                  Table capt aligns widths headers body)
                          <$> elementContent
      _ -> throwLuaError ("Unknown block type: " ++ tag)
 where
   -- Get the contents of an AST element.
   elementContent :: FromLuaStack a => Lua a
   elementContent = getTable idx "c"

-- | Push an inline element to the top of the lua stack.
pushInline :: Inline -> Lua ()
pushInline = \case
  Cite citations lst       -> pushViaConstructor "Cite" lst citations
  Code attr lst            -> pushViaConstructor "Code" lst (LuaAttr attr)
  Emph inlns               -> pushViaConstructor "Emph" inlns
  Image attr alt (src,tit) -> pushViaConstructor "Image" alt src tit (LuaAttr attr)
  LineBreak                -> pushViaConstructor "LineBreak"
  Link attr lst (src,tit)  -> pushViaConstructor "Link" lst src tit (LuaAttr attr)
  Note blcks               -> pushViaConstructor "Note" blcks
  Math mty str             -> pushViaConstructor "Math" mty str
  Quoted qt inlns          -> pushViaConstructor "Quoted" qt inlns
  RawInline f cs           -> pushViaConstructor "RawInline" f cs
  SmallCaps inlns          -> pushViaConstructor "SmallCaps" inlns
  SoftBreak                -> pushViaConstructor "SoftBreak"
  Space                    -> pushViaConstructor "Space"
  Span attr inlns          -> pushViaConstructor "Span" inlns (LuaAttr attr)
  Str str                  -> pushViaConstructor "Str" str
  Strikeout inlns          -> pushViaConstructor "Strikeout" inlns
  Strong inlns             -> pushViaConstructor "Strong" inlns
  Subscript inlns          -> pushViaConstructor "Subscript" inlns
  Superscript inlns        -> pushViaConstructor "Superscript" inlns

-- | Return the value at the given index as inline if possible.
peekInline :: StackIndex -> Lua Inline
peekInline idx = do
  tag <- getTag idx
  case tag of
    "Cite"       -> uncurry Cite <$> elementContent
    "Code"       -> withAttr Code <$> elementContent
    "Emph"       -> Emph <$> elementContent
    "Image"      -> (\(LuaAttr attr, lst, tgt) -> Image attr lst tgt)
                    <$> elementContent
    "Link"       -> (\(LuaAttr attr, lst, tgt) -> Link attr lst tgt)
                    <$> elementContent
    "LineBreak"  -> return LineBreak
    "Note"       -> Note <$> elementContent
    "Math"       -> uncurry Math <$> elementContent
    "Quoted"     -> uncurry Quoted <$> elementContent
    "RawInline"  -> uncurry RawInline <$> elementContent
    "SmallCaps"  -> SmallCaps <$> elementContent
    "SoftBreak"  -> return SoftBreak
    "Space"      -> return Space
    "Span"       -> withAttr Span <$> elementContent
    "Str"        -> Str <$> elementContent
    "Strikeout"  -> Strikeout <$> elementContent
    "Strong"     -> Strong <$> elementContent
    "Subscript"  -> Subscript <$> elementContent
    "Superscript"-> Superscript <$> elementContent
    _ -> throwLuaError ("Unknown inline type: " ++ tag)
 where
   -- Get the contents of an AST element.
   elementContent :: FromLuaStack a => Lua a
   elementContent = getTable idx "c"

getTag :: StackIndex -> Lua String
getTag idx = do
  top <- Lua.gettop
  hasMT <- Lua.getmetatable idx
  push "tag"
  if hasMT then Lua.rawget (-2) else Lua.rawget (idx `adjustIndexBy` 1)
  r <- tryLua (peek (-1))
  Lua.settop top
  case r of
    Left (Lua.LuaException err) -> throwLuaError err
    Right res                   -> return res

withAttr :: (Attr -> a -> b) -> (LuaAttr, a) -> b
withAttr f (attributes, x) = f (fromLuaAttr attributes) x

-- | Wrapper for Attr
newtype LuaAttr = LuaAttr { fromLuaAttr :: Attr }

instance ToLuaStack LuaAttr where
  push (LuaAttr (id', classes, kv)) =
    pushViaConstructor "Attr" id' classes kv

instance FromLuaStack LuaAttr where
  peek idx = LuaAttr <$> peek idx

--
-- Hierarchical elements
--
instance ToLuaStack Element where
  push (Blk blk) = push blk
  push (Sec lvl num attr label contents) = do
    Lua.newtable
    LuaUtil.addValue "level" lvl
    LuaUtil.addValue "numbering" num
    LuaUtil.addValue "attr" (LuaAttr attr)
    LuaUtil.addValue "label" label
    LuaUtil.addValue "contents" contents
    pushSecMetaTable
    Lua.setmetatable (-2)
      where
        pushSecMetaTable :: Lua ()
        pushSecMetaTable = do
          inexistant <- Lua.newmetatable "PandocElementSec"
          when inexistant $ do
            LuaUtil.addValue "t" "Sec"
            Lua.push "__index"
            Lua.pushvalue (-2)
            Lua.rawset (-3)