df23d96 · typeable/pandoc

git.iko.soy/typeable/pandoc

Generalize tableWith, gridTableWith

The parsing functions `tableWith` and `gridTableWith` are generalized to work with more parsers. The parser state only has to be an instance of the `HasOptions` class instead of requiring a concrete type. Block parsers are required to return blocks wrapped into a monad, as this makes it possible to use parsers returning results wrapped in `Future`s.

commitdf23d96c8991b215ead8ceb11607c5bebfb1f6db authorAlbert Krewinkel <albert@zeitkraut.de> dateTue 2 May 2017, 23:41 (10 years ago) parent79855ef

2 files changed+35−26

compare with master

unifiedsplit

src/Text/Pandoc/Parsing.hs+26−23 src/Text/Pandoc/Readers/RST.hs+9−3

src/Text/Pandoc/Parsing.hs+26−23

@@ -762,21 +762,22 @@ lineBlockLines = try $ do

762762

763763-- | Parse a table using 'headerParser', 'rowParser',

764764-- 'lineParser', and 'footerParser'.

765−tableWith :: Stream s m Char

766− => ParserT s ParserState m ([Blocks], [Alignment], [Int])

767− -> ([Int] -> ParserT s ParserState m [Blocks])

768− -> ParserT s ParserState m sep

769− -> ParserT s ParserState m end

770− -> ParserT s ParserState m Blocks

765+tableWith :: (Stream s m Char, HasReaderOptions st,

766+ Functor mf, Applicative mf, Monad mf)

767+ => ParserT s st m (mf [Blocks], [Alignment], [Int])

768+ -> ([Int] -> ParserT s st m (mf [Blocks]))

769+ -> ParserT s st m sep

770+ -> ParserT s st m end

771+ -> ParserT s st m (mf Blocks)

771772tableWith headerParser rowParser lineParser footerParser = try $ do

772773 (heads, aligns, indices) <- headerParser

773− lines' <- rowParser indices `sepEndBy1` lineParser

774+ lines' <- sequence <$> rowParser indices `sepEndBy1` lineParser

774775 footerParser

775776 numColumns <- getOption readerColumns

776777 let widths = if (indices == [])

777778 then replicate (length aligns) 0.0

778779 else widthsFromIndices numColumns indices

779− return $ B.table mempty (zip aligns widths) heads lines'

780+ return $ B.table mempty (zip aligns widths) <$> heads <*> lines'

780781

781782-- Calculate relative widths of table columns, based on indices

782783widthsFromIndices :: Int -- Number of columns on terminal

@@ -809,10 +810,11 @@ widthsFromIndices numColumns' indices =

809810-- (which may be grid), then the rows,

810811-- which may be grid, separated by blank lines, and

811812-- ending with a footer (dashed line followed by blank line).

812−gridTableWith :: Stream [Char] m Char

813− => ParserT [Char] ParserState m Blocks -- ^ Block list parser

814− -> Bool -- ^ Headerless table

815− -> ParserT [Char] ParserState m Blocks

813+gridTableWith :: (Stream [Char] m Char, HasReaderOptions st,

814+ Functor mf, Applicative mf, Monad mf)

815+ => ParserT [Char] st m (mf Blocks) -- ^ Block list parser

816+ -> Bool -- ^ Headerless table

817+ -> ParserT [Char] st m (mf Blocks)

816818gridTableWith blocks headless =

817819 tableWith (gridTableHeader headless blocks) (gridTableRow blocks)

818820 (gridTableSep '-') gridTableFooter

@@ -835,14 +837,14 @@ removeFinalBar =

835837 reverse . dropWhile (`elem` " \t") . dropWhile (=='|') . reverse

836838

837839-- | Separator between rows of grid table.

838−gridTableSep :: Stream s m Char => Char -> ParserT s ParserState m Char

840+gridTableSep :: Stream s m Char => Char -> ParserT s st m Char

839841gridTableSep ch = try $ gridDashedLines ch >> return '\n'

840842

841843-- | Parse header for a grid table.

842−gridTableHeader :: Stream [Char] m Char

844+gridTableHeader :: (Stream [Char] m Char, Functor mf, Applicative mf, Monad mf)

843845 => Bool -- ^ Headerless table

844− -> ParserT [Char] ParserState m Blocks

845− -> ParserT [Char] ParserState m ([Blocks], [Alignment], [Int])

846+ -> ParserT [Char] st m (mf Blocks)

847+ -> ParserT [Char] st m (mf [Blocks], [Alignment], [Int])

846848gridTableHeader headless blocks = try $ do

847849 optional blanklines

848850 dashes <- gridDashedLines '-'

@@ -862,25 +864,26 @@ gridTableHeader headless blocks = try $ do

862864 then replicate (length dashes) ""

863865 else map (intercalate " ") $ transpose

864866 $ map (gridTableSplitLine indices) rawContent

865− heads <- mapM (parseFromString blocks) $ map trim rawHeads

867+ heads <- fmap sequence . mapM (parseFromString blocks) $ map trim rawHeads

866868 return (heads, aligns, indices)

867869

868−gridTableRawLine :: Stream s m Char => [Int] -> ParserT s ParserState m [String]

870+gridTableRawLine :: Stream s m Char => [Int] -> ParserT s st m [String]

869871gridTableRawLine indices = do

870872 char '|'

871873 line <- many1Till anyChar newline

872874 return (gridTableSplitLine indices line)

873875

874876-- | Parse row of grid table.

875−gridTableRow :: Stream [Char] m Char

876− => ParserT [Char] ParserState m Blocks

877+gridTableRow :: (Stream [Char] m Char, Functor mf, Applicative mf, Monad mf)

878+ => ParserT [Char] st m (mf Blocks)

877879 -> [Int]

878− -> ParserT [Char] ParserState m [Blocks]

880+ -> ParserT [Char] st m (mf [Blocks])

879881gridTableRow blocks indices = do

880882 colLines <- many1 (gridTableRawLine indices)

881883 let cols = map ((++ "\n") . unlines . removeOneLeadingSpace) $

882884 transpose colLines

883− mapM (liftM compactifyCell . parseFromString blocks) cols

885+ cells <- sequence <$> mapM (parseFromString blocks) cols

886+ return $ fmap (map compactifyCell) cells

884887

885888removeOneLeadingSpace :: [String] -> [String]

886889removeOneLeadingSpace xs =

@@ -894,7 +897,7 @@ compactifyCell :: Blocks -> Blocks

894897compactifyCell bs = head $ compactify [bs]

895898

896899-- | Parse footer for a grid table.

897−gridTableFooter :: Stream s m Char => ParserT s ParserState m [Char]

900+gridTableFooter :: Stream s m Char => ParserT s st m [Char]

898901gridTableFooter = blanklines

899902

900903---

src/Text/Pandoc/Readers/RST.hs+9−3

@@ -32,6 +32,7 @@ Conversion from reStructuredText to 'Pandoc' document.

3232-}

3333module Text.Pandoc.Readers.RST ( readRST ) where

3434import Control.Monad (guard, liftM, mzero, when)

35+import Control.Monad.Identity (Identity(..))

3536import Control.Monad.Except (throwError)

3637import Data.Char (isHexDigit, isSpace, toLower, toUpper)

3738import Data.List (deleteFirstsBy, findIndex, intercalate, isInfixOf, isSuffixOf,

@@ -1119,8 +1120,12 @@ simpleTable :: PandocMonad m

11191120 => Bool -- ^ Headerless table

11201121 -> RSTParser m Blocks

11211122simpleTable headless = do

1122− tbl <- tableWith (simpleTableHeader headless) simpleTableRow

1123− sep simpleTableFooter

1123+ let wrapIdFst (a, b, c) = (Identity a, b, c)

1124+ wrapId = fmap Identity

1125+ tbl <- runIdentity <$> tableWith

1126+ (wrapIdFst <$> simpleTableHeader headless)

1127+ (wrapId <$> simpleTableRow)

1128+ sep simpleTableFooter

11241129 -- Simple tables get 0s for relative column widths (i.e., use default)

11251130 case B.toList tbl of

11261131 [Table c a _w h l] -> return $ B.singleton $

@@ -1134,7 +1139,8 @@ simpleTable headless = do

11341139gridTable :: PandocMonad m

11351140 => Bool -- ^ Headerless table

11361141 -> RSTParser m Blocks

1137−gridTable headerless = gridTableWith parseBlocks headerless

1142+gridTable headerless = runIdentity <$>

1143+ gridTableWith (Identity <$> parseBlocks) headerless

11381144

11391145table :: PandocMonad m => RSTParser m Blocks

11401146table = gridTable False <|> simpleTable False <|>