bc7e846 · typeable/pandoc

git.iko.soy/typeable/pandoc

on master help sign in

More logging-related changes.

bc7e846John MacFarlane10 years ago

pandoc.hs+9−10

compare with master

unifiedsplit

@@ -35,8 +35,7 @@ import Text.Pandoc.Builder (setMeta)

35import Text.Pandoc.PDF (makePDF)

36import Text.Pandoc.Walk (walk)

37import Text.Pandoc.Shared ( tabFilter, readDataFileUTF8, readDataFile,

38− safeRead, headerShift, err, warn,

38+ safeRead, headerShift, err, openURL )

39− openURL )

40import Text.Pandoc.MediaBag ( mediaDirectory, extractMediaBag, MediaBag )

39import Text.Pandoc.MediaBag ( mediaDirectory, extractMediaBag, MediaBag )

41import Text.Pandoc.XML ( toEntities )

40import Text.Pandoc.XML ( toEntities )

42import Text.Pandoc.SelfContained ( makeSelfContained )

41import Text.Pandoc.SelfContained ( makeSelfContained )

@@ -75,7 +74,7 @@ import System.Posix.Terminal (queryTerminal)

75import System.Posix.IO (stdOutput)

74import System.Posix.IO (stdOutput)

76#endif

75#endif

77import Control.Monad.Trans

76import Control.Monad.Trans

78−import Text.Pandoc.Class (withMediaBag, PandocIO, getWarnings)

77+import Text.Pandoc.Class (withMediaBag, PandocIO, getLog, setVerbosity)

80main :: IO ()

79main :: IO ()

81main = do

80main = do

@@ -354,14 +353,14 @@ convertWithOpts opts args = do

354

353

355 let runIO' :: PandocIO a -> IO a

354 let runIO' :: PandocIO a -> IO a

356 runIO' f = do

355 runIO' f = do

357− (res, warnings) <- runIOorExplode $ do

356+ (res, reports) <- runIOorExplode $ do

357+ setVerbosity verbosity

358 x <- f

359− ws <- getWarnings

359+ rs <- getLog

360− return (x, ws)

360+ return (x, rs)

361− when (not (null warnings)) $ do

361+ let isWarning (WARNING, _) = True

362− -- TODO make these streaming

362+ isWarning _ = False

363− when (verbosity >= WARNING) $ mapM_ warn warnings

364− when failIfWarnings $

363+ when (failIfWarnings && any isWarning reports) $

365 err 3 "Failing because there were warnings."

364 err 3 "Failing because there were warnings."

366 return res

365 return res

367

366

src/Text/Pandoc/Class.hs+22−23

@@ -42,7 +42,7 @@ module Text.Pandoc.Class ( PandocMonad(..)

42 , getZonedTime

43 , warning

44 , warningWithPos

45− , getWarnings

45+ , report

46 , getLog

47 , setVerbosity

48 , getMediaBag

@@ -59,7 +59,6 @@ module Text.Pandoc.Class ( PandocMonad(..)

59 , runIOorExplode

60 , runPure

61 , withMediaBag

62− , withWarningsToStderr

63 ) where

62 ) where

65import Prelude hiding (readFile)

64import Prelude hiding (readFile)

@@ -69,8 +68,8 @@ import Codec.Archive.Zip (Archive, fromArchive, emptyArchive)

69import Data.Unique (hashUnique)

68import Data.Unique (hashUnique)

70import qualified Data.Unique as IO (newUnique)

69import qualified Data.Unique as IO (newUnique)

71import qualified Text.Pandoc.Shared as IO ( readDataFile

70import qualified Text.Pandoc.Shared as IO ( readDataFile

72− , warn

73 , openURL )

71 , openURL )

72+import qualified Text.Pandoc.UTF8 as UTF8

74import Text.Pandoc.Compat.Time (UTCTime)

73import Text.Pandoc.Compat.Time (UTCTime)

75import Text.Pandoc.Options (Verbosity(..))

74import Text.Pandoc.Options (Verbosity(..))

76import Text.Pandoc.Parsing (ParserT, SourcePos)

75import Text.Pandoc.Parsing (ParserT, SourcePos)

@@ -102,10 +101,12 @@ import Control.Monad.RWS (RWST)

102import Data.Word (Word8)

101import Data.Word (Word8)

103import Data.Default

102import Data.Default

104import System.IO.Error

103import System.IO.Error

104+import System.IO (stderr)

105import qualified Data.Map as M

106import Text.Pandoc.Error

107import Data.Monoid

108import Data.Maybe (catMaybes)

109+import Text.Printf (printf)

109

110

110class (Functor m, Applicative m, Monad m, MonadError PandocError m)

111class (Functor m, Applicative m, Monad m, MonadError PandocError m)

111 => PandocMonad m where

112 => PandocMonad m where

@@ -131,13 +132,7 @@ class (Functor m, Applicative m, Monad m, MonadError PandocError m)

131 modifyCommonState :: (CommonState -> CommonState) -> m ()

132 modifyCommonState :: (CommonState -> CommonState) -> m ()

132 modifyCommonState f = getCommonState >>= putCommonState . f

133 modifyCommonState f = getCommonState >>= putCommonState . f

133

134

134− -- Can be overridden when you want log to be written to

135− -- stderr in a streaming fashion

136− report :: Verbosity -> String -> m ()

135+ logOutput :: Verbosity -> String -> m ()

137− report level msg = do

138− verbosity <- getsCommonState stVerbosity

139− when (level >= verbosity) $

140− modifyCommonState $ \st -> st{ stLog = (level, msg) : stLog st }

141

136

142-- Functions defined for all PandocMonad instances

137-- Functions defined for all PandocMonad instances

143

138

@@ -146,7 +141,7 @@ setVerbosity verbosity =

146 modifyCommonState $ \st -> st{ stVerbosity = verbosity }

141 modifyCommonState $ \st -> st{ stVerbosity = verbosity }

147

142

148getLog :: PandocMonad m => m [(Verbosity, String)]

143getLog :: PandocMonad m => m [(Verbosity, String)]

149−getLog = getsCommonState stLog

144+getLog = reverse <$> getsCommonState stLog

150

145

151warning :: PandocMonad m => String -> m ()

146warning :: PandocMonad m => String -> m ()

152warning msg = report WARNING msg

147warning msg = report WARNING msg

@@ -157,11 +152,13 @@ warningWithPos :: PandocMonad m

157 -> ParserT s st m ()

152 -> ParserT s st m ()

158warningWithPos pos msg = lift $ warning $ msg ++ " " ++ show pos

153warningWithPos pos msg = lift $ warning $ msg ++ " " ++ show pos

159

154

160−-- TODO get rid of this?

161−getWarnings :: PandocMonad m => m [String]

155+report :: PandocMonad m => Verbosity -> String -> m ()

162−getWarnings = do

156+report level msg = do

163− logs <- getLog

157+ verbosity <- getsCommonState stVerbosity

164− return [s | (WARNING, s) <- logs]

158+ when (level <= verbosity) $ do

159+ logOutput verbosity msg

160+ unless (level == DEBUG) $

161+ modifyCommonState $ \st -> st{ stLog = (level, msg) : stLog st }

165

162

166setMediaBag :: PandocMonad m => MediaBag -> m ()

163setMediaBag :: PandocMonad m => MediaBag -> m ()

167setMediaBag mb = modifyCommonState $

164setMediaBag mb = modifyCommonState $

@@ -255,12 +252,6 @@ runIO ma = flip evalStateT def $ runExceptT $ unPandocIO ma

255withMediaBag :: PandocMonad m => m a -> m (a, MediaBag)

252withMediaBag :: PandocMonad m => m a -> m (a, MediaBag)

256withMediaBag ma = ((,)) <$> ma <*> getMediaBag

253withMediaBag ma = ((,)) <$> ma <*> getMediaBag

257

254

258−withWarningsToStderr :: PandocIO a -> PandocIO a

259−withWarningsToStderr f = do

260− x <- f

261− getWarnings >>= mapM_ IO.warn

262− return x

263−

264runIOorExplode :: PandocIO a -> IO a

255runIOorExplode :: PandocIO a -> IO a

265runIOorExplode ma = runIO ma >>= handleError

256runIOorExplode ma = runIO ma >>= handleError

266

257

@@ -309,7 +300,8 @@ instance PandocMonad PandocIO where

309 Left _ -> throwError $ PandocFileReadError fp

300 Left _ -> throwError $ PandocFileReadError fp

310 getCommonState = PandocIO $ lift get

301 getCommonState = PandocIO $ lift get

311 putCommonState x = PandocIO $ lift $ put x

302 putCommonState x = PandocIO $ lift $ put x

312−

303+ logOutput level msg =

304+ liftIO $ UTF8.hPutStrLn stderr $ printf "%-7s %s" (show level) msg

313

305

314-- | Specialized version of parseURIReference that disallows

306-- | Specialized version of parseURIReference that disallows

315-- single-letter schemes. Reason: these are usually windows absolute

307-- single-letter schemes. Reason: these are usually windows absolute

@@ -508,6 +500,8 @@ instance PandocMonad PandocPure where

508 getCommonState = PandocPure $ lift $ get

500 getCommonState = PandocPure $ lift $ get

509 putCommonState x = PandocPure $ lift $ put x

501 putCommonState x = PandocPure $ lift $ put x

510

502

503+ logOutput _level _msg = return ()

504+

511instance PandocMonad m => PandocMonad (ParserT s st m) where

505instance PandocMonad m => PandocMonad (ParserT s st m) where

512 lookupEnv = lift . lookupEnv

506 lookupEnv = lift . lookupEnv

513 getCurrentTime = lift getCurrentTime

507 getCurrentTime = lift getCurrentTime

@@ -522,6 +516,7 @@ instance PandocMonad m => PandocMonad (ParserT s st m) where

522 getModificationTime = lift . getModificationTime

516 getModificationTime = lift . getModificationTime

523 getCommonState = lift getCommonState

517 getCommonState = lift getCommonState

524 putCommonState = lift . putCommonState

518 putCommonState = lift . putCommonState

519+ logOutput lvl = lift . logOutput lvl

525

520

526instance PandocMonad m => PandocMonad (ReaderT r m) where

521instance PandocMonad m => PandocMonad (ReaderT r m) where

527 lookupEnv = lift . lookupEnv

522 lookupEnv = lift . lookupEnv

@@ -537,6 +532,7 @@ instance PandocMonad m => PandocMonad (ReaderT r m) where

537 getModificationTime = lift . getModificationTime

532 getModificationTime = lift . getModificationTime

538 getCommonState = lift getCommonState

533 getCommonState = lift getCommonState

539 putCommonState = lift . putCommonState

534 putCommonState = lift . putCommonState

535+ logOutput lvl = lift . logOutput lvl

540

536

541instance (PandocMonad m, Monoid w) => PandocMonad (WriterT w m) where

537instance (PandocMonad m, Monoid w) => PandocMonad (WriterT w m) where

542 lookupEnv = lift . lookupEnv

538 lookupEnv = lift . lookupEnv

@@ -552,6 +548,7 @@ instance (PandocMonad m, Monoid w) => PandocMonad (WriterT w m) where

552 getModificationTime = lift . getModificationTime

548 getModificationTime = lift . getModificationTime

553 getCommonState = lift getCommonState

549 getCommonState = lift getCommonState

554 putCommonState = lift . putCommonState

550 putCommonState = lift . putCommonState

551+ logOutput lvl = lift . report lvl

555

552

556instance (PandocMonad m, Monoid w) => PandocMonad (RWST r w st m) where

553instance (PandocMonad m, Monoid w) => PandocMonad (RWST r w st m) where

557 lookupEnv = lift . lookupEnv

554 lookupEnv = lift . lookupEnv

@@ -567,6 +564,7 @@ instance (PandocMonad m, Monoid w) => PandocMonad (RWST r w st m) where

567 getModificationTime = lift . getModificationTime

564 getModificationTime = lift . getModificationTime

568 getCommonState = lift getCommonState

565 getCommonState = lift getCommonState

569 putCommonState = lift . putCommonState

566 putCommonState = lift . putCommonState

567+ logOutput lvl = lift . logOutput lvl

570

568

571instance PandocMonad m => PandocMonad (StateT st m) where

569instance PandocMonad m => PandocMonad (StateT st m) where

572 lookupEnv = lift . lookupEnv

570 lookupEnv = lift . lookupEnv

@@ -582,4 +580,5 @@ instance PandocMonad m => PandocMonad (StateT st m) where

582 getModificationTime = lift . getModificationTime

580 getModificationTime = lift . getModificationTime

583 getCommonState = lift getCommonState

581 getCommonState = lift getCommonState

584 putCommonState = lift . putCommonState

582 putCommonState = lift . putCommonState

583+ logOutput lvl = lift . logOutput lvl

585

584

src/Text/Pandoc/Readers/HTML.hs+5−9

@@ -45,7 +45,7 @@ import qualified Text.Pandoc.Builder as B

45import Text.Pandoc.Builder (Blocks, Inlines, trimInlines, HasMeta(..))

46import Text.Pandoc.Shared ( extractSpaces, renderTags', addMetaField

47 , escapeURI, safeRead )

48−import Text.Pandoc.Options (ReaderOptions(readerParseRaw, readerVerbosity),

48+import Text.Pandoc.Options (ReaderOptions(readerParseRaw),

49 Verbosity(..), Extension (Ext_epub_html_exts,

50 Ext_native_divs, Ext_native_spans))

51import Text.Pandoc.Parsing hiding ((<|>))

@@ -54,12 +54,11 @@ import qualified Data.Map as M

54import Data.Maybe ( fromMaybe, isJust)

55import Data.List ( intercalate, isInfixOf, isPrefixOf )

56import Data.Char ( isDigit )

57−import Control.Monad ( guard, when, mzero, void, unless )

57+import Control.Monad ( guard, mzero, void, unless )

58import Control.Arrow ((***))

59import Control.Applicative ( (<|>) )

60import Data.Monoid (First (..))

61import Text.Printf (printf)

62−import Debug.Trace (trace)

63import Text.TeXMath (readMathML, writeTeX)

62import Text.TeXMath (readMathML, writeTeX)

64import Data.Default (Default (..), def)

63import Data.Default (Default (..), def)

65import Control.Monad.Reader (ask, asks, local, ReaderT, runReaderT, lift)

64import Control.Monad.Reader (ask, asks, local, ReaderT, runReaderT, lift)

@@ -69,7 +68,7 @@ import Data.Monoid ((<>))

69import Text.Parsec.Error

68import Text.Parsec.Error

70import qualified Data.Set as Set

69import qualified Data.Set as Set

71import Text.Pandoc.Error

70import Text.Pandoc.Error

72−import Text.Pandoc.Class (PandocMonad)

71+import Text.Pandoc.Class (PandocMonad, report)

73import Control.Monad.Except (throwError)

72import Control.Monad.Except (throwError)

@@ -96,8 +95,6 @@ readHtml opts inp = do

96 case result of

95 case result of

97 Right doc -> return doc

96 Right doc -> return doc

98 Left err -> throwError $ PandocParseError $ getError err

97 Left err -> throwError $ PandocParseError $ getError err

99−

100− where

101

102replaceNotes :: PandocMonad m => [Block] -> TagParser m [Block]

99replaceNotes :: PandocMonad m => [Block] -> TagParser m [Block]

103replaceNotes = walkM replaceNotes'

100replaceNotes = walkM replaceNotes'

@@ -160,7 +157,6 @@ pHead = pInTags "head" $ pTitle <|> pMetaTag <|> pBaseTag <|> (mempty <$ pAnyTag

160

157

161block :: PandocMonad m => TagParser m Blocks

158block :: PandocMonad m => TagParser m Blocks

162block = do

159block = do

163− tr <- (== DEBUG) <$> getOption readerVerbosity

164 pos <- getPosition

160 pos <- getPosition

165 res <- choice

161 res <- choice

166 [ eSection

162 [ eSection

@@ -181,8 +177,8 @@ block = do

181 , pPlain

177 , pPlain

182 , pRawHtmlBlock

178 , pRawHtmlBlock

183 ]

179 ]

184− when tr $ trace (printf "line %d: %s" (sourceLine pos)

180+ report DEBUG $ printf "line %d: %s"

185− (take 60 $ show $ B.toList res)) (return ())

181+ (sourceLine pos) (take 60 $ show $ B.toList res)

186 return res

182 return res

187

183

188namespaces :: PandocMonad m => [(String, TagParser m Inlines)]

184namespaces :: PandocMonad m => [(String, TagParser m Inlines)]

src/Text/Pandoc/Readers/Markdown.hs+3−7

@@ -62,11 +62,10 @@ import Control.Monad

62import System.FilePath (takeExtension, addExtension)

63import Text.HTML.TagSoup

64import Text.Printf (printf)

65−import Debug.Trace (trace)

66import Data.Monoid ((<>))

65import Data.Monoid ((<>))

67import Control.Monad.Trans (lift)

66import Control.Monad.Trans (lift)

68import Control.Monad.Except (throwError, catchError)

67import Control.Monad.Except (throwError, catchError)

69−import Text.Pandoc.Class (PandocMonad)

68+import Text.Pandoc.Class (PandocMonad, report)

70import qualified Text.Pandoc.Class as P

69import qualified Text.Pandoc.Class as P

72type MarkdownParser m = ParserT [Char] ParserState m

71type MarkdownParser m = ParserT [Char] ParserState m

@@ -490,7 +489,6 @@ parseBlocks = mconcat <$> manyTill block eof

490

489

491block :: PandocMonad m => MarkdownParser m (F Blocks)

490block :: PandocMonad m => MarkdownParser m (F Blocks)

492block = do

491block = do

493− tr <- (== DEBUG) <$> getOption readerVerbosity

494 pos <- getPosition

492 pos <- getPosition

495 res <- choice [ mempty <$ blanklines

493 res <- choice [ mempty <$ blanklines

496 , codeBlockFenced

494 , codeBlockFenced

@@ -517,10 +515,8 @@ block = do

517 , para

515 , para

518 , plain

516 , plain

519 ] <?> "block"

517 ] <?> "block"

520− when tr $ do

521− st <- getState

522− trace (printf "line %d: %s" (sourceLine pos)

518+ report DEBUG $ printf "line %d: %s" (sourceLine pos)

523− (take 60 $ show $ B.toList $ runF res st)) (return ())

519+ (take 60 $ show $ B.toList $ runF res defaultParserState)

524 return res

520 return res

525

521

526--

522--

src/Text/Pandoc/Readers/MediaWiki.hs+3−6

@@ -56,9 +56,8 @@ import qualified Data.Set as Set

56import Data.Char (isDigit, isSpace)

57import Data.Maybe (fromMaybe)

58import Text.Printf (printf)

59−import Debug.Trace (trace)

60import Control.Monad.Except (throwError)

59import Control.Monad.Except (throwError)

61−import Text.Pandoc.Class (PandocMonad)

60+import Text.Pandoc.Class (PandocMonad, report)

63-- | Read mediawiki from an input string and return a Pandoc document.

62-- | Read mediawiki from an input string and return a Pandoc document.

64readMediaWiki :: PandocMonad m

63readMediaWiki :: PandocMonad m

@@ -194,7 +193,6 @@ parseMediaWiki = do

194

193

195block :: PandocMonad m => MWParser m Blocks

194block :: PandocMonad m => MWParser m Blocks

196block = do

195block = do

197− tr <- (== DEBUG) <$> getOption readerVerbosity

198 pos <- getPosition

196 pos <- getPosition

199 res <- mempty <$ skipMany1 blankline

197 res <- mempty <$ skipMany1 blankline

200 <|> table

198 <|> table

@@ -208,9 +206,8 @@ block = do

208 <|> blockTag

206 <|> blockTag

209 <|> (B.rawBlock "mediawiki" <$> template)

207 <|> (B.rawBlock "mediawiki" <$> template)

210 <|> para

208 <|> para

211− when tr $

212− trace (printf "line %d: %s" (sourceLine pos)

209+ report DEBUG $ printf "line %d: %s" (sourceLine pos)

213− (take 60 $ show $ B.toList res)) (return ())

210+ (take 60 $ show $ B.toList res)

214 return res

211 return res

215

212

216para :: PandocMonad m => MWParser m Blocks

213para :: PandocMonad m => MWParser m Blocks

src/Text/Pandoc/Readers/TWiki.hs+78−71

@@ -39,39 +39,38 @@ import Text.Pandoc.Parsing hiding (enclosed, macro, nested)

39import Text.Pandoc.Readers.HTML (htmlTag, isCommentTag)

40import Control.Monad

41import Text.Printf (printf)

42−import Debug.Trace (trace)

43import Text.Pandoc.XML (fromEntities)

42import Text.Pandoc.XML (fromEntities)

44import Data.Maybe (fromMaybe)

43import Data.Maybe (fromMaybe)

45import Text.HTML.TagSoup

44import Text.HTML.TagSoup

46import Data.Char (isAlphaNum)

45import Data.Char (isAlphaNum)

47import qualified Data.Foldable as F

46import qualified Data.Foldable as F

48import Control.Monad.Except (throwError)

47import Control.Monad.Except (throwError)

49−import Text.Pandoc.Class (PandocMonad)

48+import Text.Pandoc.Class (PandocMonad, report)

51-- | Read twiki from an input string and return a Pandoc document.

50-- | Read twiki from an input string and return a Pandoc document.

52readTWiki :: PandocMonad m

51readTWiki :: PandocMonad m

53 => ReaderOptions

52 => ReaderOptions

54 -> String

53 -> String

55 -> m Pandoc

54 -> m Pandoc

56−readTWiki opts s =

55+readTWiki opts s = do

57− case (readWith parseTWiki) def{ stateOptions = opts } (s ++ "\n\n") of

56+ res <- readWithM parseTWiki def{ stateOptions = opts } (s ++ "\n\n")

57+ case res of

58 Left e -> throwError e

59 Right d -> return d

61−

62−type TWParser = Parser [Char] ParserState

61+type TWParser = ParserT [Char] ParserState

64--

63--

65-- utility functions

64-- utility functions

66--

65--

68−tryMsg :: String -> TWParser a -> TWParser a

67+tryMsg :: String -> TWParser m a -> TWParser m a

69tryMsg msg p = try p <?> msg

68tryMsg msg p = try p <?> msg

71−skip :: TWParser a -> TWParser ()

70+skip :: TWParser m a -> TWParser m ()

72skip parser = parser >> return ()

71skip parser = parser >> return ()

74−nested :: TWParser a -> TWParser a

73+nested :: PandocMonad m => TWParser m a -> TWParser m a

75nested p = do

74nested p = do

76 nestlevel <- stateMaxNestingLevel <$> getState

75 nestlevel <- stateMaxNestingLevel <$> getState

77 guard $ nestlevel > 0

76 guard $ nestlevel > 0

@@ -80,7 +79,7 @@ nested p = do

80 updateState $ \st -> st{ stateMaxNestingLevel = nestlevel }

79 updateState $ \st -> st{ stateMaxNestingLevel = nestlevel }

81 return res

80 return res

83−htmlElement :: String -> TWParser (Attr, String)

82+htmlElement :: PandocMonad m => String -> TWParser m (Attr, String)

84htmlElement tag = tryMsg tag $ do

83htmlElement tag = tryMsg tag $ do

85 (TagOpen _ attr, _) <- htmlTag (~== TagOpen tag [])

84 (TagOpen _ attr, _) <- htmlTag (~== TagOpen tag [])

86 content <- manyTill anyChar (endtag <|> endofinput)

85 content <- manyTill anyChar (endtag <|> endofinput)

@@ -97,7 +96,8 @@ htmlAttrToPandoc attrs = (ident, classes, keyvals)

97 classes = maybe [] words $ lookup "class" attrs

96 classes = maybe [] words $ lookup "class" attrs

98 keyvals = [(k,v) | (k,v) <- attrs, k /= "id" && k /= "class"]

97 keyvals = [(k,v) | (k,v) <- attrs, k /= "id" && k /= "class"]

99+parseHtmlContentWithAttrs :: PandocMonad m

100−parseHtmlContentWithAttrs :: String -> TWParser a -> TWParser (Attr, [a])

100+ => String -> TWParser m a -> TWParser m (Attr, [a])

101parseHtmlContentWithAttrs tag parser = do

102 (attr, content) <- htmlElement tag

103 parsedContent <- try $ parseContent content

@@ -106,14 +106,14 @@ parseHtmlContentWithAttrs tag parser = do

106 parseContent = parseFromString $ nested $ manyTill parser endOfContent

107 endOfContent = try $ skipMany blankline >> skipSpaces >> eof

108

109−parseHtmlContent :: String -> TWParser a -> TWParser [a]

109+parseHtmlContent :: PandocMonad m => String -> TWParser m a -> TWParser m [a]

110parseHtmlContent tag p = parseHtmlContentWithAttrs tag p >>= return . snd

111

112--

113-- main parser

114--

115

116−parseTWiki :: TWParser Pandoc

116+parseTWiki :: PandocMonad m => TWParser m Pandoc

117parseTWiki = do

118 bs <- mconcat <$> many block

119 spaces

@@ -125,20 +125,18 @@ parseTWiki = do

125-- block parsers

126--

127

128−block :: TWParser B.Blocks

128+block :: PandocMonad m => TWParser m B.Blocks

129block = do

130− tr <- (== DEBUG) <$> getOption readerVerbosity

131 pos <- getPosition

130 pos <- getPosition

132 res <- mempty <$ skipMany1 blankline

131 res <- mempty <$ skipMany1 blankline

133 <|> blockElements

132 <|> blockElements

134 <|> para

133 <|> para

135 skipMany blankline

134 skipMany blankline

136− when tr $

137− trace (printf "line %d: %s" (sourceLine pos)

135+ report DEBUG $ printf "line %d: %s" (sourceLine pos)

138− (take 60 $ show $ B.toList res)) (return ())

136+ (take 60 $ show $ B.toList res)

139 return res

137 return res

140

138

141−blockElements :: TWParser B.Blocks

139+blockElements :: PandocMonad m => TWParser m B.Blocks

142blockElements = choice [ separator

140blockElements = choice [ separator

143 , header

141 , header

144 , verbatim

142 , verbatim

@@ -149,10 +147,10 @@ blockElements = choice [ separator

149 , noautolink

147 , noautolink

150 ]

148 ]

151

149

152−separator :: TWParser B.Blocks

150+separator :: PandocMonad m => TWParser m B.Blocks

153separator = tryMsg "separator" $ string "---" >> newline >> return B.horizontalRule

151separator = tryMsg "separator" $ string "---" >> newline >> return B.horizontalRule

154

152

155−header :: TWParser B.Blocks

153+header :: PandocMonad m => TWParser m B.Blocks

156header = tryMsg "header" $ do

154header = tryMsg "header" $ do

157 string "---"

155 string "---"

158 level <- many1 (char '+') >>= return . length

156 level <- many1 (char '+') >>= return . length

@@ -163,43 +161,45 @@ header = tryMsg "header" $ do

163 attr <- registerHeader ("", classes, []) content

161 attr <- registerHeader ("", classes, []) content

164 return $ B.headerWith attr level $ content

162 return $ B.headerWith attr level $ content

165

163

166−verbatim :: TWParser B.Blocks

164+verbatim :: PandocMonad m => TWParser m B.Blocks

167verbatim = (htmlElement "verbatim" <|> htmlElement "pre")

165verbatim = (htmlElement "verbatim" <|> htmlElement "pre")

168 >>= return . (uncurry B.codeBlockWith)

166 >>= return . (uncurry B.codeBlockWith)

169

167

170−literal :: TWParser B.Blocks

168+literal :: PandocMonad m => TWParser m B.Blocks

171literal = htmlElement "literal" >>= return . rawBlock

169literal = htmlElement "literal" >>= return . rawBlock

172 where

170 where

173 format (_, _, kvs) = fromMaybe "html" $ lookup "format" kvs

171 format (_, _, kvs) = fromMaybe "html" $ lookup "format" kvs

174 rawBlock (attrs, content) = B.rawBlock (format attrs) content

172 rawBlock (attrs, content) = B.rawBlock (format attrs) content

175

173

176−list :: String -> TWParser B.Blocks

174+list :: PandocMonad m => String -> TWParser m B.Blocks

177list prefix = choice [ bulletList prefix

175list prefix = choice [ bulletList prefix

178 , orderedList prefix

176 , orderedList prefix

179 , definitionList prefix]

177 , definitionList prefix]

180

178

181−definitionList :: String -> TWParser B.Blocks

179+definitionList :: PandocMonad m => String -> TWParser m B.Blocks

182definitionList prefix = tryMsg "definitionList" $ do

180definitionList prefix = tryMsg "definitionList" $ do

183 indent <- lookAhead $ string prefix *> (many1 $ string " ") <* string "$ "

181 indent <- lookAhead $ string prefix *> (many1 $ string " ") <* string "$ "

184 elements <- many $ parseDefinitionListItem (prefix ++ concat indent)

182 elements <- many $ parseDefinitionListItem (prefix ++ concat indent)

185 return $ B.definitionList elements

183 return $ B.definitionList elements

186 where

184 where

185+ parseDefinitionListItem :: PandocMonad m

187− parseDefinitionListItem :: String -> TWParser (B.Inlines, [B.Blocks])

186+ => String -> TWParser m (B.Inlines, [B.Blocks])

188 parseDefinitionListItem indent = do

187 parseDefinitionListItem indent = do

189 string (indent ++ "$ ") >> skipSpaces

188 string (indent ++ "$ ") >> skipSpaces

190 term <- many1Till inline $ string ": "

189 term <- many1Till inline $ string ": "

191 line <- listItemLine indent $ string "$ "

190 line <- listItemLine indent $ string "$ "

192 return $ (mconcat term, [line])

191 return $ (mconcat term, [line])

193

192

194−bulletList :: String -> TWParser B.Blocks

193+bulletList :: PandocMonad m => String -> TWParser m B.Blocks

195bulletList prefix = tryMsg "bulletList" $

194bulletList prefix = tryMsg "bulletList" $

196 parseList prefix (char '*') (char ' ')

195 parseList prefix (char '*') (char ' ')

197

196

198−orderedList :: String -> TWParser B.Blocks

197+orderedList :: PandocMonad m => String -> TWParser m B.Blocks

199orderedList prefix = tryMsg "orderedList" $

198orderedList prefix = tryMsg "orderedList" $

200 parseList prefix (oneOf "1iIaA") (string ". ")

199 parseList prefix (oneOf "1iIaA") (string ". ")

201

200

201+parseList :: PandocMonad m

202−parseList :: String -> TWParser Char -> TWParser a -> TWParser B.Blocks

202+ => String -> TWParser m Char -> TWParser m a -> TWParser m B.Blocks

203parseList prefix marker delim = do

204 (indent, style) <- lookAhead $ string prefix *> listStyle <* delim

205 blocks <- many $ parseListItem (prefix ++ indent) (char style <* delim)

@@ -216,10 +216,12 @@ parseList prefix marker delim = do

216 style <- marker

217 return (concat indent, style)

218

219+parseListItem :: (PandocMonad m, Show a)

219−parseListItem :: Show a => String -> TWParser a -> TWParser B.Blocks

220+ => String -> TWParser m a -> TWParser m B.Blocks

220parseListItem prefix marker = string prefix >> marker >> listItemLine prefix marker

221parseListItem prefix marker = string prefix >> marker >> listItemLine prefix marker

221

222

223+listItemLine :: (PandocMonad m, Show a)

222−listItemLine :: Show a => String -> TWParser a -> TWParser B.Blocks

224+ => String -> TWParser m a -> TWParser m B.Blocks

223listItemLine prefix marker = lineContent >>= parseContent >>= return . mconcat

225listItemLine prefix marker = lineContent >>= parseContent >>= return . mconcat

224 where

226 where

225 lineContent = do

227 lineContent = do

@@ -236,7 +238,7 @@ listItemLine prefix marker = lineContent >>= parseContent >>= return . mconcat

236 lastNewline = try $ char '\n' <* eof

238 lastNewline = try $ char '\n' <* eof

237 newlineBeforeNestedList = try $ char '\n' <* lookAhead nestedList

239 newlineBeforeNestedList = try $ char '\n' <* lookAhead nestedList

238

240

239−table :: TWParser B.Blocks

241+table :: PandocMonad m => TWParser m B.Blocks

240table = try $ do

242table = try $ do

241 tableHead <- optionMaybe $ many1Till tableParseHeader newline >>= return . unzip

243 tableHead <- optionMaybe $ many1Till tableParseHeader newline >>= return . unzip

242 rows <- many1 tableParseRow

244 rows <- many1 tableParseRow

@@ -248,7 +250,7 @@ table = try $ do

248 columns rows = replicate (columCount rows) mempty

250 columns rows = replicate (columCount rows) mempty

249 columCount rows = length $ head rows

251 columCount rows = length $ head rows

250

252

251−tableParseHeader :: TWParser ((Alignment, Double), B.Blocks)

253+tableParseHeader :: PandocMonad m => TWParser m ((Alignment, Double), B.Blocks)

252tableParseHeader = try $ do

254tableParseHeader = try $ do

253 char '|'

255 char '|'

254 leftSpaces <- many spaceChar >>= return . length

256 leftSpaces <- many spaceChar >>= return . length

@@ -264,27 +266,27 @@ tableParseHeader = try $ do

264 | left > right = (AlignRight, 0)

266 | left > right = (AlignRight, 0)

265 | otherwise = (AlignLeft, 0)

267 | otherwise = (AlignLeft, 0)

266

268

267−tableParseRow :: TWParser [B.Blocks]

269+tableParseRow :: PandocMonad m => TWParser m [B.Blocks]

268tableParseRow = many1Till tableParseColumn newline

270tableParseRow = many1Till tableParseColumn newline

269

271

270−tableParseColumn :: TWParser B.Blocks

272+tableParseColumn :: PandocMonad m => TWParser m B.Blocks

271tableParseColumn = char '|' *> skipSpaces *>

273tableParseColumn = char '|' *> skipSpaces *>

272 tableColumnContent (skipSpaces >> char '|')

274 tableColumnContent (skipSpaces >> char '|')

273 <* skipSpaces <* optional tableEndOfRow

275 <* skipSpaces <* optional tableEndOfRow

274

276

275−tableEndOfRow :: TWParser Char

277+tableEndOfRow :: PandocMonad m => TWParser m Char

276tableEndOfRow = lookAhead (try $ char '|' >> char '\n') >> char '|'

278tableEndOfRow = lookAhead (try $ char '|' >> char '\n') >> char '|'

277

279

278−tableColumnContent :: TWParser a -> TWParser B.Blocks

280+tableColumnContent :: PandocMonad m => TWParser m a -> TWParser m B.Blocks

279tableColumnContent end = manyTill content (lookAhead $ try end) >>= return . B.plain . mconcat

281tableColumnContent end = manyTill content (lookAhead $ try end) >>= return . B.plain . mconcat

280 where

282 where

281 content = continuation <|> inline

283 content = continuation <|> inline

282 continuation = try $ char '\\' >> newline >> return mempty

284 continuation = try $ char '\\' >> newline >> return mempty

283

285

284−blockQuote :: TWParser B.Blocks

286+blockQuote :: PandocMonad m => TWParser m B.Blocks

285blockQuote = parseHtmlContent "blockquote" block >>= return . B.blockQuote . mconcat

287blockQuote = parseHtmlContent "blockquote" block >>= return . B.blockQuote . mconcat

286

288

287−noautolink :: TWParser B.Blocks

289+noautolink :: PandocMonad m => TWParser m B.Blocks

288noautolink = do

290noautolink = do

289 (_, content) <- htmlElement "noautolink"

291 (_, content) <- htmlElement "noautolink"

290 st <- getState

292 st <- getState

@@ -295,7 +297,7 @@ noautolink = do

295 where

297 where

296 parseContent = parseFromString $ many $ block

298 parseContent = parseFromString $ many $ block

297

299

298−para :: TWParser B.Blocks

300+para :: PandocMonad m => TWParser m B.Blocks

299para = many1Till inline endOfParaElement >>= return . result . mconcat

301para = many1Till inline endOfParaElement >>= return . result . mconcat

300 where

302 where

301 endOfParaElement = lookAhead $ endOfInput <|> endOfPara <|> newBlockElement

303 endOfParaElement = lookAhead $ endOfInput <|> endOfPara <|> newBlockElement

@@ -311,7 +313,7 @@ para = many1Till inline endOfParaElement >>= return . result . mconcat

311-- inline parsers

313-- inline parsers

312--

314--

313

315

314−inline :: TWParser B.Inlines

316+inline :: PandocMonad m => TWParser m B.Inlines

315inline = choice [ whitespace

317inline = choice [ whitespace

316 , br

318 , br

317 , macro

319 , macro

@@ -332,36 +334,39 @@ inline = choice [ whitespace

332 , symbol

334 , symbol

333 ] <?> "inline"

335 ] <?> "inline"

334

336

335−whitespace :: TWParser B.Inlines

337+whitespace :: PandocMonad m => TWParser m B.Inlines

336whitespace = (lb <|> regsp) >>= return

338whitespace = (lb <|> regsp) >>= return

337 where lb = try $ skipMany spaceChar >> linebreak >> return B.space

339 where lb = try $ skipMany spaceChar >> linebreak >> return B.space

338 regsp = try $ skipMany1 spaceChar >> return B.space

340 regsp = try $ skipMany1 spaceChar >> return B.space

339

341

340−br :: TWParser B.Inlines

342+br :: PandocMonad m => TWParser m B.Inlines

341br = try $ string "%BR%" >> return B.linebreak

343br = try $ string "%BR%" >> return B.linebreak

342

344

343−linebreak :: TWParser B.Inlines

345+linebreak :: PandocMonad m => TWParser m B.Inlines

344linebreak = newline >> notFollowedBy newline >> (lastNewline <|> innerNewline)

346linebreak = newline >> notFollowedBy newline >> (lastNewline <|> innerNewline)

345 where lastNewline = eof >> return mempty

347 where lastNewline = eof >> return mempty

346 innerNewline = return B.space

348 innerNewline = return B.space

347

349

350+between :: (Monoid c, PandocMonad m)

348−between :: (Monoid c) => TWParser a -> TWParser b -> (TWParser b -> TWParser c) -> TWParser c

351+ => TWParser m a -> TWParser m b -> (TWParser m b -> TWParser m c)

352+ -> TWParser m c

349between start end p =

353between start end p =

350 mconcat <$> try (start >> notFollowedBy whitespace >> many1Till (p end) end)

354 mconcat <$> try (start >> notFollowedBy whitespace >> many1Till (p end) end)

351

355

356+enclosed :: (Monoid b, PandocMonad m)

352−enclosed :: (Monoid b) => TWParser a -> (TWParser a -> TWParser b) -> TWParser b

357+ => TWParser m a -> (TWParser m a -> TWParser m b) -> TWParser m b

353enclosed sep p = between sep (try $ sep <* endMarker) p

358enclosed sep p = between sep (try $ sep <* endMarker) p

354 where

359 where

355 endMarker = lookAhead $ skip endSpace <|> skip (oneOf ".,!?:)|") <|> eof

360 endMarker = lookAhead $ skip endSpace <|> skip (oneOf ".,!?:)|") <|> eof

356 endSpace = (spaceChar <|> newline) >> return B.space

361 endSpace = (spaceChar <|> newline) >> return B.space

357

362

358−macro :: TWParser B.Inlines

363+macro :: PandocMonad m => TWParser m B.Inlines

359macro = macroWithParameters <|> withoutParameters

364macro = macroWithParameters <|> withoutParameters

360 where

365 where

361 withoutParameters = enclosed (char '%') (\_ -> macroName) >>= return . emptySpan

366 withoutParameters = enclosed (char '%') (\_ -> macroName) >>= return . emptySpan

362 emptySpan name = buildSpan name [] mempty

367 emptySpan name = buildSpan name [] mempty

363

368

364−macroWithParameters :: TWParser B.Inlines

369+macroWithParameters :: PandocMonad m => TWParser m B.Inlines

365macroWithParameters = try $ do

370macroWithParameters = try $ do

366 char '%'

371 char '%'

367 name <- macroName

372 name <- macroName

@@ -376,13 +381,13 @@ buildSpan className kvs = B.spanWith attrs

376 additionalClasses = maybe [] words $ lookup "class" kvs

381 additionalClasses = maybe [] words $ lookup "class" kvs

377 kvsWithoutClasses = [(k,v) | (k,v) <- kvs, k /= "class"]

382 kvsWithoutClasses = [(k,v) | (k,v) <- kvs, k /= "class"]

378

383

379−macroName :: TWParser String

384+macroName :: PandocMonad m => TWParser m String

380macroName = do

385macroName = do

381 first <- letter

386 first <- letter

382 rest <- many $ alphaNum <|> char '_'

387 rest <- many $ alphaNum <|> char '_'

383 return (first:rest)

388 return (first:rest)

384

389

385−attributes :: TWParser (String, [(String, String)])

390+attributes :: PandocMonad m => TWParser m (String, [(String, String)])

386attributes = char '{' *> spnl *> many (attribute <* spnl) <* char '}' >>=

391attributes = char '{' *> spnl *> many (attribute <* spnl) <* char '}' >>=

387 return . foldr (either mkContent mkKvs) ([], [])

392 return . foldr (either mkContent mkKvs) ([], [])

388 where

393 where

@@ -391,7 +396,7 @@ attributes = char '{' *> spnl *> many (attribute <* spnl) <* char '}' >>=

391 mkContent c (rest, kvs) = (c ++ " " ++ rest, kvs)

396 mkContent c (rest, kvs) = (c ++ " " ++ rest, kvs)

392 mkKvs kv (cont, rest) = (cont, (kv : rest))

397 mkKvs kv (cont, rest) = (cont, (kv : rest))

393

398

394−attribute :: TWParser (Either String (String, String))

399+attribute :: PandocMonad m => TWParser m (Either String (String, String))

395attribute = withKey <|> withoutKey

400attribute = withKey <|> withoutKey

396 where

401 where

397 withKey = try $ do

402 withKey = try $ do

@@ -405,49 +410,51 @@ attribute = withKey <|> withoutKey

405 | allowSpaces == True = many1 $ noneOf "}"

410 | allowSpaces == True = many1 $ noneOf "}"

406 | otherwise = many1 $ noneOf " }"

411 | otherwise = many1 $ noneOf " }"

407

412

413+nestedInlines :: (Show a, PandocMonad m)

408−nestedInlines :: Show a => TWParser a -> TWParser B.Inlines

414+ => TWParser m a -> TWParser m B.Inlines

409nestedInlines end = innerSpace <|> nestedInline

415nestedInlines end = innerSpace <|> nestedInline

410 where

416 where

411 innerSpace = try $ whitespace <* (notFollowedBy end)

417 innerSpace = try $ whitespace <* (notFollowedBy end)

412 nestedInline = notFollowedBy whitespace >> nested inline

418 nestedInline = notFollowedBy whitespace >> nested inline

413

419

414−strong :: TWParser B.Inlines

420+strong :: PandocMonad m => TWParser m B.Inlines

415strong = try $ enclosed (char '*') nestedInlines >>= return . B.strong

421strong = try $ enclosed (char '*') nestedInlines >>= return . B.strong

416

422

417−strongHtml :: TWParser B.Inlines

423+strongHtml :: PandocMonad m => TWParser m B.Inlines

418strongHtml = (parseHtmlContent "strong" inline <|> parseHtmlContent "b" inline)

424strongHtml = (parseHtmlContent "strong" inline <|> parseHtmlContent "b" inline)

419 >>= return . B.strong . mconcat

425 >>= return . B.strong . mconcat

420

426

421−strongAndEmph :: TWParser B.Inlines

427+strongAndEmph :: PandocMonad m => TWParser m B.Inlines

422strongAndEmph = try $ enclosed (string "__") nestedInlines >>= return . B.emph . B.strong

428strongAndEmph = try $ enclosed (string "__") nestedInlines >>= return . B.emph . B.strong

423

429

424−emph :: TWParser B.Inlines

430+emph :: PandocMonad m => TWParser m B.Inlines

425emph = try $ enclosed (char '_') nestedInlines >>= return . B.emph

431emph = try $ enclosed (char '_') nestedInlines >>= return . B.emph

426

432

427−emphHtml :: TWParser B.Inlines

433+emphHtml :: PandocMonad m => TWParser m B.Inlines

428emphHtml = (parseHtmlContent "em" inline <|> parseHtmlContent "i" inline)

434emphHtml = (parseHtmlContent "em" inline <|> parseHtmlContent "i" inline)

429 >>= return . B.emph . mconcat

435 >>= return . B.emph . mconcat

430

436

437+nestedString :: (Show a, PandocMonad m)

431−nestedString :: Show a => TWParser a -> TWParser String

438+ => TWParser m a -> TWParser m String

432nestedString end = innerSpace <|> (count 1 nonspaceChar)

439nestedString end = innerSpace <|> (count 1 nonspaceChar)

433 where

440 where

434 innerSpace = try $ many1 spaceChar <* notFollowedBy end

441 innerSpace = try $ many1 spaceChar <* notFollowedBy end

435

442

436−boldCode :: TWParser B.Inlines

443+boldCode :: PandocMonad m => TWParser m B.Inlines

437boldCode = try $ enclosed (string "==") nestedString >>= return . B.strong . B.code . fromEntities

444boldCode = try $ enclosed (string "==") nestedString >>= return . B.strong . B.code . fromEntities

438

445

439−htmlComment :: TWParser B.Inlines

446+htmlComment :: PandocMonad m => TWParser m B.Inlines

440htmlComment = htmlTag isCommentTag >> return mempty

447htmlComment = htmlTag isCommentTag >> return mempty

441

448

442−code :: TWParser B.Inlines

449+code :: PandocMonad m => TWParser m B.Inlines

443code = try $ enclosed (char '=') nestedString >>= return . B.code . fromEntities

450code = try $ enclosed (char '=') nestedString >>= return . B.code . fromEntities

444

451

445−codeHtml :: TWParser B.Inlines

452+codeHtml :: PandocMonad m => TWParser m B.Inlines

446codeHtml = do

453codeHtml = do

447 (attrs, content) <- parseHtmlContentWithAttrs "code" anyChar

454 (attrs, content) <- parseHtmlContentWithAttrs "code" anyChar

448 return $ B.codeWith attrs $ fromEntities content

455 return $ B.codeWith attrs $ fromEntities content

449

456

450−autoLink :: TWParser B.Inlines

457+autoLink :: PandocMonad m => TWParser m B.Inlines

451autoLink = try $ do

458autoLink = try $ do

452 state <- getState

459 state <- getState

453 guard $ stateAllowLinks state

460 guard $ stateAllowLinks state

@@ -461,20 +468,20 @@ autoLink = try $ do

461 | c == '/' = True

468 | c == '/' = True

462 | otherwise = isAlphaNum c

469 | otherwise = isAlphaNum c

463

470

464−str :: TWParser B.Inlines

471+str :: PandocMonad m => TWParser m B.Inlines

465str = (many1 alphaNum <|> count 1 characterReference) >>= return . B.str

472str = (many1 alphaNum <|> count 1 characterReference) >>= return . B.str

466

473

467−nop :: TWParser B.Inlines

474+nop :: PandocMonad m => TWParser m B.Inlines

468nop = try $ (skip exclamation <|> skip nopTag) >> followContent

475nop = try $ (skip exclamation <|> skip nopTag) >> followContent

469 where

476 where

470 exclamation = char '!'

477 exclamation = char '!'

471 nopTag = stringAnyCase "<nop>"

478 nopTag = stringAnyCase "<nop>"

472 followContent = many1 nonspaceChar >>= return . B.str . fromEntities

479 followContent = many1 nonspaceChar >>= return . B.str . fromEntities

473

480

474−symbol :: TWParser B.Inlines

481+symbol :: PandocMonad m => TWParser m B.Inlines

475symbol = count 1 nonspaceChar >>= return . B.str

482symbol = count 1 nonspaceChar >>= return . B.str

476

483

477−smart :: TWParser B.Inlines

484+smart :: PandocMonad m => TWParser m B.Inlines

478smart = do

485smart = do

479 guardEnabled Ext_smart

486 guardEnabled Ext_smart

480 doubleQuoted <|> singleQuoted <|>

487 doubleQuoted <|> singleQuoted <|>

@@ -483,14 +490,14 @@ smart = do

483 , ellipses

490 , ellipses

484 ]

491 ]

485

492

486−singleQuoted :: TWParser B.Inlines

493+singleQuoted :: PandocMonad m => TWParser m B.Inlines

487singleQuoted = try $ do

494singleQuoted = try $ do

488 singleQuoteStart

495 singleQuoteStart

489 withQuoteContext InSingleQuote $

496 withQuoteContext InSingleQuote $

490 many1Till inline singleQuoteEnd >>=

497 many1Till inline singleQuoteEnd >>=

491 (return . B.singleQuoted . B.trimInlines . mconcat)

498 (return . B.singleQuoted . B.trimInlines . mconcat)

492

499

493−doubleQuoted :: TWParser B.Inlines

500+doubleQuoted :: PandocMonad m => TWParser m B.Inlines

494doubleQuoted = try $ do

501doubleQuoted = try $ do

495 doubleQuoteStart

502 doubleQuoteStart

496 contents <- mconcat <$> many (try $ notFollowedBy doubleQuoteEnd >> inline)

503 contents <- mconcat <$> many (try $ notFollowedBy doubleQuoteEnd >> inline)

@@ -498,7 +505,7 @@ doubleQuoted = try $ do

498 return (B.doubleQuoted $ B.trimInlines contents))

505 return (B.doubleQuoted $ B.trimInlines contents))

499 <|> (return $ (B.str "\8220") B.<> contents)

506 <|> (return $ (B.str "\8220") B.<> contents)

500

507

501−link :: TWParser B.Inlines

508+link :: PandocMonad m => TWParser m B.Inlines

502link = try $ do

509link = try $ do

503 st <- getState

510 st <- getState

504 guard $ stateAllowLinks st

511 guard $ stateAllowLinks st

@@ -507,7 +514,7 @@ link = try $ do

507 setState $ st{ stateAllowLinks = True }

514 setState $ st{ stateAllowLinks = True }

508 return $ B.link url title content

515 return $ B.link url title content

509

516

510−linkText :: TWParser (String, String, B.Inlines)

517+linkText :: PandocMonad m => TWParser m (String, String, B.Inlines)

511linkText = do

518linkText = do

512 string "[["

519 string "[["

513 url <- many1Till anyChar (char ']')

520 url <- many1Till anyChar (char ']')

src/Text/Pandoc/Readers/Textile.hs+4−7

@@ -64,11 +64,10 @@ import Text.HTML.TagSoup (fromAttrib, Tag(..))

64import Text.HTML.TagSoup.Match

65import Data.List ( intercalate, transpose, intersperse )

66import Data.Char ( digitToInt, isUpper )

67−import Control.Monad ( guard, liftM, when )

67+import Control.Monad ( guard, liftM )

68import Data.Monoid ((<>))

69import Text.Printf

70−import Debug.Trace (trace)

71−import Text.Pandoc.Class (PandocMonad)

70+import Text.Pandoc.Class (PandocMonad, report)

72import Control.Monad.Except (throwError)

71import Control.Monad.Except (throwError)

74-- | Parse a Textile text and return a Pandoc document.

73-- | Parse a Textile text and return a Pandoc document.

@@ -147,10 +146,8 @@ block :: PandocMonad m => ParserT [Char] ParserState m Blocks

147block = do

146block = do

148 res <- choice blockParsers <?> "block"

147 res <- choice blockParsers <?> "block"

149 pos <- getPosition

148 pos <- getPosition

150− tr <- (== DEBUG) <$> getOption readerVerbosity

151− when tr $

152− trace (printf "line %d: %s" (sourceLine pos)

149+ report DEBUG $ printf "line %d: %s" (sourceLine pos)

153− (take 60 $ show $ B.toList res)) (return ())

150+ (take 60 $ show $ B.toList res)

154 return res

151 return res

155

152

156commentBlock :: PandocMonad m => ParserT [Char] ParserState m Blocks

153commentBlock :: PandocMonad m => ParserT [Char] ParserState m Blocks