fb2e92b · typeable/pandoc

37import Text.Pandoc.Pretty (render)

38import Text.Pandoc.Templates (renderTemplate')

39import Text.Pandoc.XML ( escapeStringForXML )

40−import Data.List ( intersect, intercalate, intersperse )

40+import Data.List ( intersect, intercalate )

41import Network.URI ( isURI )

42+import Control.Monad.Reader

42import Control.Monad.State

43import Control.Monad.State

43

44

44data WriterState = WriterState {

45data WriterState = WriterState {

45 stNotes :: Bool -- True if there are notes

46 stNotes :: Bool -- True if there are notes

46− , stListLevel :: [Char] -- String at beginning of list items, e.g. "**"

47− , stUseTags :: Bool -- True if we should use HTML tags because we're in a complex list

48 }

47 }

49

48

49+data WriterReader = WriterReader {

50+ options :: WriterOptions -- Writer options

51+ , stListLevel :: String -- String at beginning of list items, e.g. "**"

52+ , stUseTags :: Bool -- True if we should use HTML tags because we're in a complex list

53+ }

54+

55+type MediaWikiWriter = ReaderT WriterReader (State WriterState)

56+

50-- | Convert Pandoc to MediaWiki.

57-- | Convert Pandoc to MediaWiki.

51writeMediaWiki :: WriterOptions -> Pandoc -> String

58writeMediaWiki :: WriterOptions -> Pandoc -> String

52writeMediaWiki opts document =

59writeMediaWiki opts document =

53− evalState (pandocToMediaWiki opts document)

54− WriterState { stNotes = False, stListLevel = [], stUseTags = False }

60+ let initialState = WriterState { stNotes = False }

61+ env = WriterReader { options = opts, stListLevel = [], stUseTags = False }

62+ in evalState (runReaderT (pandocToMediaWiki document) env) initialState

55

63

56-- | Return MediaWiki representation of document.

64-- | Return MediaWiki representation of document.

57−pandocToMediaWiki :: WriterOptions -> Pandoc -> State WriterState String

65+pandocToMediaWiki :: Pandoc -> MediaWikiWriter String

58−pandocToMediaWiki opts (Pandoc meta blocks) = do

66+pandocToMediaWiki (Pandoc meta blocks) = do

67+ opts <- asks options

59 metadata <- metaToJSON opts

68 metadata <- metaToJSON opts

60− (fmap trimr . blockListToMediaWiki opts)

69+ (fmap trimr . blockListToMediaWiki)

61− (inlineListToMediaWiki opts)

70+ inlineListToMediaWiki

62 meta

71 meta

63− body <- blockListToMediaWiki opts blocks

72+ body <- blockListToMediaWiki blocks

64− notesExist <- get >>= return . stNotes

73+ notesExist <- gets stNotes

65 let notes = if notesExist

74 let notes = if notesExist

66 then "\n<references />"

75 then "\n<references />"

67 else ""

76 else ""

68 let main = body ++ notes

77 let main = body ++ notes

69 let context = defField "body" main

78 let context = defField "body" main

70− $ defField "toc" (writerTableOfContents opts)

79+ $ defField "toc" (writerTableOfContents opts) metadata

71− $ metadata

72− if writerStandalone opts

80+ return $ if writerStandalone opts

73− then return $ renderTemplate' (writerTemplate opts) context

81+ then renderTemplate' (writerTemplate opts) context

74− else return main

82+ else main

75

83

76-- | Escape special characters for MediaWiki.

84-- | Escape special characters for MediaWiki.

77escapeString :: String -> String

85escapeString :: String -> String

78escapeString = escapeStringForXML

86escapeString = escapeStringForXML

79

87

80-- | Convert Pandoc block element to MediaWiki.

88-- | Convert Pandoc block element to MediaWiki.

81−blockToMediaWiki :: WriterOptions -- ^ Options

82− -> Block -- ^ Block element

89+blockToMediaWiki :: Block -- ^ Block element

83− -> State WriterState String

90+ -> MediaWikiWriter String

84

91

85−blockToMediaWiki _ Null = return ""

92+blockToMediaWiki Null = return ""

86

93

87−blockToMediaWiki opts (Div attrs bs) = do

94+blockToMediaWiki (Div attrs bs) = do

88− contents <- blockListToMediaWiki opts bs

95+ contents <- blockListToMediaWiki bs

89 return $ render Nothing (tagWithAttrs "div" attrs) ++ "\n\n" ++

96 return $ render Nothing (tagWithAttrs "div" attrs) ++ "\n\n" ++

90 contents ++ "\n\n" ++ "</div>"

97 contents ++ "\n\n" ++ "</div>"

91

98

92−blockToMediaWiki opts (Plain inlines) =

99+blockToMediaWiki (Plain inlines) =

93− inlineListToMediaWiki opts inlines

100+ inlineListToMediaWiki inlines

94

101

95-- title beginning with fig: indicates that the image is a figure

102-- title beginning with fig: indicates that the image is a figure

96−blockToMediaWiki opts (Para [Image txt (src,'f':'i':'g':':':tit)]) = do

103+blockToMediaWiki (Para [Image txt (src,'f':'i':'g':':':tit)]) = do

97 capt <- if null txt

104 capt <- if null txt

98 then return ""

105 then return ""

99− else ("|caption " ++) `fmap` inlineListToMediaWiki opts txt

106+ else ("|caption " ++) `fmap` inlineListToMediaWiki txt

100 let opt = if null txt

107 let opt = if null txt

101 then ""

108 then ""

102 else "|alt=" ++ if null tit then capt else tit ++ capt

109 else "|alt=" ++ if null tit then capt else tit ++ capt

103 return $ "[[Image:" ++ src ++ "|frame|none" ++ opt ++ "]]\n"

110 return $ "[[Image:" ++ src ++ "|frame|none" ++ opt ++ "]]\n"

104

111

105−blockToMediaWiki opts (Para inlines) = do

112+blockToMediaWiki (Para inlines) = do

106− useTags <- get >>= return . stUseTags

113+ useTags <- asks stUseTags

107− listLevel <- get >>= return . stListLevel

114+ listLevel <- asks stListLevel

108− contents <- inlineListToMediaWiki opts inlines

115+ contents <- inlineListToMediaWiki inlines

109 return $ if useTags

116 return $ if useTags

110 then "" ++ contents ++ ""

117 then "" ++ contents ++ ""

111 else contents ++ if null listLevel then "\n" else ""

118 else contents ++ if null listLevel then "\n" else ""

112

119

113−blockToMediaWiki _ (RawBlock f str)

120+blockToMediaWiki (RawBlock f str)

114 | f == Format "mediawiki" = return str

121 | f == Format "mediawiki" = return str

115 | f == Format "html" = return str

122 | f == Format "html" = return str

116 | otherwise = return ""

123 | otherwise = return ""

117

124

118−blockToMediaWiki _ HorizontalRule = return "\n-----\n"

125+blockToMediaWiki HorizontalRule = return "\n-----\n"

119

126

120−blockToMediaWiki opts (Header level _ inlines) = do

127+blockToMediaWiki (Header level _ inlines) = do

121− contents <- inlineListToMediaWiki opts inlines

128+ contents <- inlineListToMediaWiki inlines

122 let eqs = replicate level '='

129 let eqs = replicate level '='

123 return $ eqs ++ " " ++ contents ++ " " ++ eqs ++ "\n"

130 return $ eqs ++ " " ++ contents ++ " " ++ eqs ++ "\n"

124

131

125−blockToMediaWiki _ (CodeBlock (_,classes,_) str) = do

132+blockToMediaWiki (CodeBlock (_,classes,_) str) = do

126 let at = classes `intersect` ["actionscript", "ada", "apache", "applescript", "asm", "asp",

133 let at = classes `intersect` ["actionscript", "ada", "apache", "applescript", "asm", "asp",

127 "autoit", "bash", "blitzbasic", "bnf", "c", "c_mac", "caddcl", "cadlisp", "cfdg", "cfm",

134 "autoit", "bash", "blitzbasic", "bnf", "c", "c_mac", "caddcl", "cadlisp", "cfdg", "cfm",

128 "cpp", "cpp-qt", "csharp", "css", "d", "delphi", "diff", "div", "dos", "eiffel", "fortran",

135 "cpp", "cpp-qt", "csharp", "css", "d", "delphi", "diff", "div", "dos", "eiffel", "fortran",

137 else ("<source lang=\"" ++ head at ++ "\">", "</source>")

144 else ("<source lang=\"" ++ head at ++ "\">", "</source>")

138 return $ beg ++ escapeString str ++ end

145 return $ beg ++ escapeString str ++ end

139

146

140−blockToMediaWiki opts (BlockQuote blocks) = do

147+blockToMediaWiki (BlockQuote blocks) = do

141− contents <- blockListToMediaWiki opts blocks

148+ contents <- blockListToMediaWiki blocks

142 return $ "<blockquote>" ++ contents ++ "</blockquote>"

149 return $ "<blockquote>" ++ contents ++ "</blockquote>"

143

150

144−blockToMediaWiki opts (Table capt aligns widths headers rows') = do

151+blockToMediaWiki (Table capt aligns widths headers rows') = do

145 caption <- if null capt

152 caption <- if null capt

146 then return ""

153 then return ""

147 else do

154 else do

148− c <- inlineListToMediaWiki opts capt

155+ c <- inlineListToMediaWiki capt

149 return $ "|+ " ++ trimr c ++ "\n"

156 return $ "|+ " ++ trimr c ++ "\n"

150 let headless = all null headers

157 let headless = all null headers

151 let allrows = if headless then rows' else headers:rows'

158 let allrows = if headless then rows' else headers:rows'

152− tableBody <- (concat . intersperse "|-\n") `fmap`

159+ tableBody <- intercalate "|-\n" `fmap`

153− mapM (tableRowToMediaWiki opts headless aligns widths)

160+ mapM (tableRowToMediaWiki headless aligns widths)

154 (zip [1..] allrows)

161 (zip [1..] allrows)

155 return $ "{|\n" ++ caption ++ tableBody ++ "|}\n"

162 return $ "{|\n" ++ caption ++ tableBody ++ "|}\n"

156

163

157−blockToMediaWiki opts x@(BulletList items) = do

164+blockToMediaWiki x@(BulletList items) = do

158− oldUseTags <- get >>= return . stUseTags

159− listLevel <- get >>= return . stListLevel

160− let useTags = oldUseTags || not (isSimpleList x)

165+ useTags <- fmap (|| not (isSimpleList x)) $ asks stUseTags

161 if useTags

166 if useTags

162 then do

167 then do

163− modify $ \s -> s { stUseTags = True }

168+ contents <- local (\ s -> s { stUseTags = True }) $ mapM listItemToMediaWiki items

164− contents <- mapM (listItemToMediaWiki opts) items

165− modify $ \s -> s { stUseTags = oldUseTags }

166 return $ "<ul>\n" ++ vcat contents ++ "</ul>\n"

169 return $ "<ul>\n" ++ vcat contents ++ "</ul>\n"

167 else do

170 else do

168− modify $ \s -> s { stListLevel = stListLevel s ++ "*" }

171+ listLevel <- asks stListLevel

169− contents <- mapM (listItemToMediaWiki opts) items

172+ contents <- local (\s -> s { stListLevel = stListLevel s ++ "*" }) $ mapM listItemToMediaWiki items

170− modify $ \s -> s { stListLevel = init (stListLevel s) }

171 return $ vcat contents ++ if null listLevel then "\n" else ""

173 return $ vcat contents ++ if null listLevel then "\n" else ""

172

174

173−blockToMediaWiki opts x@(OrderedList attribs items) = do

175+blockToMediaWiki x@(OrderedList attribs items) = do

174− oldUseTags <- get >>= return . stUseTags

175− listLevel <- get >>= return . stListLevel

176− let useTags = oldUseTags || not (isSimpleList x)

176+ useTags <- fmap (|| not (isSimpleList x)) $ asks stUseTags

177 if useTags

178 then do

179− modify $ \s -> s { stUseTags = True }

179+ contents <- local (\s -> s { stUseTags = True }) $ mapM listItemToMediaWiki items

180− contents <- mapM (listItemToMediaWiki opts) items

181− modify $ \s -> s { stUseTags = oldUseTags }

182 return $ "<ol" ++ listAttribsToString attribs ++ ">\n" ++ vcat contents ++ "</ol>\n"

180 return $ "<ol" ++ listAttribsToString attribs ++ ">\n" ++ vcat contents ++ "</ol>\n"

183 else do

181 else do

184− modify $ \s -> s { stListLevel = stListLevel s ++ "#" }

182+ listLevel <- asks stListLevel

185− contents <- mapM (listItemToMediaWiki opts) items

183+ contents <- local (\s -> s { stListLevel = stListLevel s ++ "#" }) $ mapM listItemToMediaWiki items

186− modify $ \s -> s { stListLevel = init (stListLevel s) }

187 return $ vcat contents ++ if null listLevel then "\n" else ""

184 return $ vcat contents ++ if null listLevel then "\n" else ""

188

185

189−blockToMediaWiki opts x@(DefinitionList items) = do

186+blockToMediaWiki x@(DefinitionList items) = do

190− oldUseTags <- get >>= return . stUseTags

191− listLevel <- get >>= return . stListLevel

192− let useTags = oldUseTags || not (isSimpleList x)

187+ useTags <- fmap (|| not (isSimpleList x)) $ asks stUseTags

193 if useTags

188 if useTags

194 then do

189 then do

195− modify $ \s -> s { stUseTags = True }

190+ contents <- local (\s -> s { stUseTags = True }) $ mapM definitionListItemToMediaWiki items

196− contents <- mapM (definitionListItemToMediaWiki opts) items

197− modify $ \s -> s { stUseTags = oldUseTags }

198 return $ "<dl>\n" ++ vcat contents ++ "</dl>\n"

191 return $ "<dl>\n" ++ vcat contents ++ "</dl>\n"

199 else do

192 else do

200− modify $ \s -> s { stListLevel = stListLevel s ++ ";" }

193+ listLevel <- asks stListLevel

201− contents <- mapM (definitionListItemToMediaWiki opts) items

194+ contents <- local (\s -> s { stListLevel = stListLevel s ++ ";" }) $ mapM definitionListItemToMediaWiki items

202− modify $ \s -> s { stListLevel = init (stListLevel s) }

203 return $ vcat contents ++ if null listLevel then "\n" else ""

195 return $ vcat contents ++ if null listLevel then "\n" else ""

204

196

205-- Auxiliary functions for lists:

197-- Auxiliary functions for lists:

216 else "")

208 else "")

217

209

218-- | Convert bullet or ordered list item (list of blocks) to MediaWiki.

210-- | Convert bullet or ordered list item (list of blocks) to MediaWiki.

219−listItemToMediaWiki :: WriterOptions -> [Block] -> State WriterState String

211+listItemToMediaWiki :: [Block] -> MediaWikiWriter String

220−listItemToMediaWiki opts items = do

212+listItemToMediaWiki items = do

221− contents <- blockListToMediaWiki opts items

213+ contents <- blockListToMediaWiki items

222− useTags <- get >>= return . stUseTags

214+ useTags <- asks stUseTags

223 if useTags

215 if useTags

224 then return $ "<li>" ++ contents ++ "</li>"

216 then return $ "<li>" ++ contents ++ "</li>"

225 else do

217 else do

226− marker <- get >>= return . stListLevel

218+ marker <- asks stListLevel

227 return $ marker ++ " " ++ contents

219 return $ marker ++ " " ++ contents

228

220

229-- | Convert definition list item (label, list of blocks) to MediaWiki.

221-- | Convert definition list item (label, list of blocks) to MediaWiki.

230−definitionListItemToMediaWiki :: WriterOptions

222+definitionListItemToMediaWiki :: ([Inline],[[Block]])

231− -> ([Inline],[[Block]])

223+ -> MediaWikiWriter String

232− -> State WriterState String

233−definitionListItemToMediaWiki opts (label, items) = do

224+definitionListItemToMediaWiki (label, items) = do

234− labelText <- inlineListToMediaWiki opts label

225+ labelText <- inlineListToMediaWiki label

235− contents <- mapM (blockListToMediaWiki opts) items

226+ contents <- mapM blockListToMediaWiki items

236− useTags <- get >>= return . stUseTags

227+ useTags <- asks stUseTags

237 if useTags

228 if useTags

238 then return $ "<dt>" ++ labelText ++ "</dt>\n" ++

229 then return $ "<dt>" ++ labelText ++ "</dt>\n" ++

239− (intercalate "\n" $ map (\d -> "<dd>" ++ d ++ "</dd>") contents)

230+ intercalate "\n" (map (\d -> "<dd>" ++ d ++ "</dd>") contents)

240 else do

231 else do

241− marker <- get >>= return . stListLevel

232+ marker <- asks stListLevel

242 return $ marker ++ " " ++ labelText ++ "\n" ++

233 return $ marker ++ " " ++ labelText ++ "\n" ++

243− (intercalate "\n" $ map (\d -> init marker ++ ": " ++ d) contents)

234+ intercalate "\n" (map (\d -> init marker ++ ": " ++ d) contents)

244

235

245-- | True if the list can be handled by simple wiki markup, False if HTML tags will be needed.

236-- | True if the list can be handled by simple wiki markup, False if HTML tags will be needed.

246isSimpleList :: Block -> Bool

237isSimpleList :: Block -> Bool

283

274

284-- Auxiliary functions for tables:

275-- Auxiliary functions for tables:

285

276

286−tableRowToMediaWiki :: WriterOptions

277+tableRowToMediaWiki :: Bool

287− -> Bool

288 -> [Alignment]

278 -> [Alignment]

289 -> [Double]

279 -> [Double]

290 -> (Int, [[Block]])

280 -> (Int, [[Block]])

291− -> State WriterState String

281+ -> MediaWikiWriter String

292−tableRowToMediaWiki opts headless alignments widths (rownum, cells) = do

282+tableRowToMediaWiki headless alignments widths (rownum, cells) = do

293− cells' <- mapM (\cellData ->

294− tableCellToMediaWiki opts headless rownum cellData)

283+ cells' <- mapM (tableCellToMediaWiki headless rownum)

295 $ zip3 alignments widths cells

284 $ zip3 alignments widths cells

296 return $ unlines cells'

285 return $ unlines cells'

297

286

298−tableCellToMediaWiki :: WriterOptions

287+tableCellToMediaWiki :: Bool

299− -> Bool

300 -> Int

288 -> Int

301 -> (Alignment, Double, [Block])

289 -> (Alignment, Double, [Block])

302− -> State WriterState String

290+ -> MediaWikiWriter String

303−tableCellToMediaWiki opts headless rownum (alignment, width, bs) = do

291+tableCellToMediaWiki headless rownum (alignment, width, bs) = do

304− contents <- blockListToMediaWiki opts bs

292+ contents <- blockListToMediaWiki bs

305 let marker = if rownum == 1 && not headless then "!" else "|"

293 let marker = if rownum == 1 && not headless then "!" else "|"

306 let percent w = show (truncate (100*w) :: Integer) ++ "%"

294 let percent w = show (truncate (100*w) :: Integer) ++ "%"

307 let attrs = ["align=" ++ show (alignmentToString alignment) |

295 let attrs = ["align=" ++ show (alignmentToString alignment) |

313 else unwords attrs ++ "|"

301 else unwords attrs ++ "|"

314 return $ marker ++ attr ++ trimr contents

302 return $ marker ++ attr ++ trimr contents

315

303

316−alignmentToString :: Alignment -> [Char]

304+alignmentToString :: Alignment -> String

317alignmentToString alignment = case alignment of

305alignmentToString alignment = case alignment of

318 AlignLeft -> "left"

306 AlignLeft -> "left"

319 AlignRight -> "right"

307 AlignRight -> "right"

321 AlignDefault -> "left"

309 AlignDefault -> "left"

322

310

323-- | Convert list of Pandoc block elements to MediaWiki.

311-- | Convert list of Pandoc block elements to MediaWiki.

324−blockListToMediaWiki :: WriterOptions -- ^ Options

325− -> [Block] -- ^ List of block elements

312+blockListToMediaWiki :: [Block] -- ^ List of block elements

326− -> State WriterState String

313+ -> MediaWikiWriter String

327−blockListToMediaWiki opts blocks =

314+blockListToMediaWiki blocks =

328− mapM (blockToMediaWiki opts) blocks >>= return . vcat

315+ fmap vcat $ mapM blockToMediaWiki blocks

329

316

330-- | Convert list of Pandoc inline elements to MediaWiki.

317-- | Convert list of Pandoc inline elements to MediaWiki.

331−inlineListToMediaWiki :: WriterOptions -> [Inline] -> State WriterState String

318+inlineListToMediaWiki :: [Inline] -> MediaWikiWriter String

332−inlineListToMediaWiki opts lst =

319+inlineListToMediaWiki lst =

333− mapM (inlineToMediaWiki opts) lst >>= return . concat

320+ fmap concat $ mapM inlineToMediaWiki lst

334

321

335-- | Convert Pandoc inline element to MediaWiki.

322-- | Convert Pandoc inline element to MediaWiki.

336−inlineToMediaWiki :: WriterOptions -> Inline -> State WriterState String

323+inlineToMediaWiki :: Inline -> MediaWikiWriter String

337

324

338−inlineToMediaWiki opts (Span attrs ils) = do

325+inlineToMediaWiki (Span attrs ils) = do

339− contents <- inlineListToMediaWiki opts ils

326+ contents <- inlineListToMediaWiki ils

340 return $ render Nothing (tagWithAttrs "span" attrs) ++ contents ++ ""

327 return $ render Nothing (tagWithAttrs "span" attrs) ++ contents ++ ""

341

328

342−inlineToMediaWiki opts (Emph lst) = do

329+inlineToMediaWiki (Emph lst) = do

343− contents <- inlineListToMediaWiki opts lst

330+ contents <- inlineListToMediaWiki lst

344 return $ "''" ++ contents ++ "''"

331 return $ "''" ++ contents ++ "''"

345

332

346−inlineToMediaWiki opts (Strong lst) = do

333+inlineToMediaWiki (Strong lst) = do

347− contents <- inlineListToMediaWiki opts lst

334+ contents <- inlineListToMediaWiki lst

348 return $ "'''" ++ contents ++ "'''"

335 return $ "'''" ++ contents ++ "'''"

349

336

350−inlineToMediaWiki opts (Strikeout lst) = do

337+inlineToMediaWiki (Strikeout lst) = do

351− contents <- inlineListToMediaWiki opts lst

338+ contents <- inlineListToMediaWiki lst

352 return $ "<s>" ++ contents ++ "</s>"

339 return $ "<s>" ++ contents ++ "</s>"

353

340

354−inlineToMediaWiki opts (Superscript lst) = do

341+inlineToMediaWiki (Superscript lst) = do

355− contents <- inlineListToMediaWiki opts lst

342+ contents <- inlineListToMediaWiki lst

356 return $ "" ++ contents ++ ""

343 return $ "" ++ contents ++ ""

357

344

358−inlineToMediaWiki opts (Subscript lst) = do

345+inlineToMediaWiki (Subscript lst) = do

359− contents <- inlineListToMediaWiki opts lst

346+ contents <- inlineListToMediaWiki lst

360 return $ "" ++ contents ++ ""

347 return $ "" ++ contents ++ ""

361

348

362−inlineToMediaWiki opts (SmallCaps lst) = inlineListToMediaWiki opts lst

349+inlineToMediaWiki (SmallCaps lst) = inlineListToMediaWiki lst

363

350

364−inlineToMediaWiki opts (Quoted SingleQuote lst) = do

351+inlineToMediaWiki (Quoted SingleQuote lst) = do

365− contents <- inlineListToMediaWiki opts lst

352+ contents <- inlineListToMediaWiki lst

366 return $ "\8216" ++ contents ++ "\8217"

353 return $ "\8216" ++ contents ++ "\8217"

367

354

368−inlineToMediaWiki opts (Quoted DoubleQuote lst) = do

355+inlineToMediaWiki (Quoted DoubleQuote lst) = do

369− contents <- inlineListToMediaWiki opts lst

356+ contents <- inlineListToMediaWiki lst

370 return $ "\8220" ++ contents ++ "\8221"

357 return $ "\8220" ++ contents ++ "\8221"

371

358

372−inlineToMediaWiki opts (Cite _ lst) = inlineListToMediaWiki opts lst

359+inlineToMediaWiki (Cite _ lst) = inlineListToMediaWiki lst

373

360

374−inlineToMediaWiki _ (Code _ str) =

361+inlineToMediaWiki (Code _ str) =

375− return $ "<code>" ++ (escapeString str) ++ "</code>"

362+ return $ "<code>" ++ escapeString str ++ "</code>"

376

363

377−inlineToMediaWiki _ (Str str) = return $ escapeString str

364+inlineToMediaWiki (Str str) = return $ escapeString str

378

365

379−inlineToMediaWiki _ (Math _ str) = return $ "<math>" ++ str ++ "</math>"

366+inlineToMediaWiki (Math _ str) = return $ "<math>" ++ str ++ "</math>"

380− -- note: str should NOT be escaped

367+ -- note: str should NOT be escaped

381

368

382−inlineToMediaWiki _ (RawInline f str)

369+inlineToMediaWiki (RawInline f str)

383 | f == Format "mediawiki" = return str

370 | f == Format "mediawiki" = return str

384 | f == Format "html" = return str

371 | f == Format "html" = return str

385 | otherwise = return ""

372 | otherwise = return ""

386

373

387−inlineToMediaWiki _ (LineBreak) = return " "

374+inlineToMediaWiki (LineBreak) = return " "

388

375

389−inlineToMediaWiki _ Space = return " "

376+inlineToMediaWiki Space = return " "

390

377

391−inlineToMediaWiki opts (Link txt (src, _)) = do

378+inlineToMediaWiki (Link txt (src, _)) = do

392− label <- inlineListToMediaWiki opts txt

379+ label <- inlineListToMediaWiki txt

393 case txt of

380 case txt of

394 [Str s] | escapeURI s == src -> return src

381 [Str s] | escapeURI s == src -> return src

395− _ -> if isURI src

382+ _ -> return $ if isURI src

396− then return $ "[" ++ src ++ " " ++ label ++ "]"

383+ then "[" ++ src ++ " " ++ label ++ "]"

397− else return $ "[[" ++ src' ++ "|" ++ label ++ "]]"

384+ else "[[" ++ src' ++ "|" ++ label ++ "]]"

398 where src' = case src of

385 where src' = case src of

399 '/':xs -> xs -- with leading / it's a

386 '/':xs -> xs -- with leading / it's a

400 _ -> src -- link to a help page

387 _ -> src -- link to a help page

388+

401−inlineToMediaWiki opts (Image alt (source, tit)) = do

389+inlineToMediaWiki (Image alt (source, tit)) = do

402− alt' <- inlineListToMediaWiki opts alt

390+ alt' <- inlineListToMediaWiki alt

403− let txt = if (null tit)

391+ let txt = if null tit

404 then if null alt

392 then if null alt

405 then ""

393 then ""

406− else "|" ++ alt'

394+ else '|' : alt'

407− else "|" ++ tit

395+ else '|' : tit

408 return $ "[[Image:" ++ source ++ txt ++ "]]"

396 return $ "[[Image:" ++ source ++ txt ++ "]]"

409

397

410−inlineToMediaWiki opts (Note contents) = do

398+inlineToMediaWiki (Note contents) = do

411− contents' <- blockListToMediaWiki opts contents

399+ contents' <- blockListToMediaWiki contents

412 modify (\s -> s { stNotes = True })

400 modify (\s -> s { stNotes = True })

413 return $ "<ref>" ++ contents' ++ "</ref>"

401 return $ "<ref>" ++ contents' ++ "</ref>"

414 -- note - may not work for notes with multiple blocks

402 -- note - may not work for notes with multiple blocks