a1677b6 · typeable/pandoc

git.iko.soy/typeable/pandoc

on master help sign in

Parsing: removed duplication of Key and Key'.

a1677b6John MacFarlane14 years ago

src/Text/Pandoc/Parsing.hs+5−38

compare with master

unifiedsplit

@@ -71,13 +71,8 @@ module Text.Pandoc.Parsing ( (>>~),

71 NoteTable,

72 NoteTable',

73 KeyTable,

74− Key,

74+ Key (..),

75 toKey,

76− fromKey,

77− lookupKeySrc,

78− KeyTable',

79− Key',

80− toKey',

81 smartPunctuation,

76 smartPunctuation,

82 withQuoteContext,

77 withQuoteContext,

83 singleQuoteStart,

78 singleQuoteStart,

@@ -145,7 +140,6 @@ where

145

140

146import Text.Pandoc.Definition

141import Text.Pandoc.Definition

147import Text.Pandoc.Options

142import Text.Pandoc.Options

148−import Text.Pandoc.Generic

149import Text.Pandoc.Builder (Blocks)

143import Text.Pandoc.Builder (Blocks)

150import qualified Text.Pandoc.UTF8 as UTF8 (putStrLn)

144import qualified Text.Pandoc.UTF8 as UTF8 (putStrLn)

151import Text.Parsec

145import Text.Parsec

@@ -706,8 +700,7 @@ data ParserState = ParserState

706 stateAllowLinks :: Bool, -- ^ Allow parsing of links

700 stateAllowLinks :: Bool, -- ^ Allow parsing of links

707 stateMaxNestingLevel :: Int, -- ^ Max # of nested Strong/Emph

701 stateMaxNestingLevel :: Int, -- ^ Max # of nested Strong/Emph

708 stateLastStrPos :: Maybe SourcePos, -- ^ Position after last str parsed

702 stateLastStrPos :: Maybe SourcePos, -- ^ Position after last str parsed

709− stateKeys :: KeyTable, -- ^ List of reference keys

703+ stateKeys :: KeyTable, -- ^ List of reference keys (with fallbacks)

710− stateKeys' :: KeyTable', -- ^ List of reference keys (with fallbacks)

711 stateNotes :: NoteTable, -- ^ List of notes (raw bodies)

704 stateNotes :: NoteTable, -- ^ List of notes (raw bodies)

712 stateNotes' :: NoteTable', -- ^ List of notes (parsed bodies)

705 stateNotes' :: NoteTable', -- ^ List of notes (parsed bodies)

713 stateTitle :: [Inline], -- ^ Title of document

706 stateTitle :: [Inline], -- ^ Title of document

@@ -733,7 +726,6 @@ defaultParserState =

733 stateMaxNestingLevel = 6,

726 stateMaxNestingLevel = 6,

734 stateLastStrPos = Nothing,

727 stateLastStrPos = Nothing,

735 stateKeys = M.empty,

728 stateKeys = M.empty,

736− stateKeys' = M.empty,

737 stateNotes = [],

729 stateNotes = [],

738 stateNotes' = [],

730 stateNotes' = [],

739 stateTitle = [],

731 stateTitle = [],

@@ -777,38 +769,13 @@ type NoteTable = [(String, String)]

777

769

778type NoteTable' = [(String, Reader ParserState Blocks)] -- used in markdown reader

770type NoteTable' = [(String, Reader ParserState Blocks)] -- used in markdown reader

779

771

780−newtype Key = Key [Inline] deriving (Show, Read, Eq, Ord)

772+newtype Key = Key String deriving (Show, Read, Eq, Ord)

781

773

782−toKey :: [Inline] -> Key

774+toKey :: String -> Key

783−toKey = Key . bottomUp lowercase

775+toKey = Key . map toLower . unwords . words

784− where lowercase :: Inline -> Inline

785− lowercase (Str xs) = Str (map toLower xs)

786− lowercase (Math t xs) = Math t (map toLower xs)

787− lowercase (Code attr xs) = Code attr (map toLower xs)

788− lowercase (RawInline f xs) = RawInline f (map toLower xs)

789− lowercase LineBreak = Space

790− lowercase x = x

791−

792−fromKey :: Key -> [Inline]

793−fromKey (Key xs) = xs

794

776

795type KeyTable = M.Map Key Target

777type KeyTable = M.Map Key Target

796

778

797−newtype Key' = Key' String deriving (Show, Read, Eq, Ord)

798−

799−toKey' :: String -> Key'

800−toKey' = Key' . map toLower . unwords . words

801−

802−type KeyTable' = M.Map Key' Target

803−

804−-- | Look up key in key table and return target object.

805−lookupKeySrc :: KeyTable -- ^ Key table

806− -> Key -- ^ Key

807− -> Maybe Target

808−lookupKeySrc table key = case M.lookup key table of

809− Nothing -> Nothing

810− Just src -> Just src

811−

812-- | Fail unless we're in "smart typography" mode.

779-- | Fail unless we're in "smart typography" mode.

813failUnlessSmart :: Parser [tok] ParserState ()

780failUnlessSmart :: Parser [tok] ParserState ()

814failUnlessSmart = getOption readerSmart >>= guard

781failUnlessSmart = getOption readerSmart >>= guard

src/Text/Pandoc/Readers/Markdown.hs+4−4

@@ -227,8 +227,8 @@ referenceKey = try $ do

227 blanklines

228 let target = (escapeURI $ removeTrailingSpace src, tit)

229 st <- getState

230− let oldkeys = stateKeys' st

230+ let oldkeys = stateKeys st

231− updateState $ \s -> s { stateKeys' = M.insert (toKey' raw) target oldkeys }

231+ updateState $ \s -> s { stateKeys = M.insert (toKey raw) target oldkeys }

232 return $ return mempty

233

234referenceTitle :: Parser [Char] ParserState String

@@ -1405,7 +1405,7 @@ referenceLink constructor (lab, raw) = do

1405 raw' <- try (optional (char ' ') >>

1406 optional (newline >> skipSpaces) >>

1407 (snd <$> reference)) <|> return ""

1408− let key = toKey' $ if raw' == "[]" || raw' == "" then raw else raw'

1408+ let key = toKey $ if raw' == "[]" || raw' == "" then raw else raw'

1409 let dropRB (']':xs) = xs

1410 dropRB xs = xs

1411 let dropLB ('[':xs) = xs

@@ -1413,7 +1413,7 @@ referenceLink constructor (lab, raw) = do

1413 let dropBrackets = reverse . dropRB . reverse . dropLB

1414 fallback <- parseFromString (mconcat <$> many inline) $ dropBrackets raw

1415 return $ do

1416− keys <- asks stateKeys'

1416+ keys <- asks stateKeys

1417 case M.lookup key keys of

1418 Nothing -> (\x -> B.str "[" <> x <> B.str "]" <> B.str raw') <$> fallback

1419 Just (src,tit) -> constructor src tit <$> lab

src/Text/Pandoc/Readers/RST.hs+19−14

@@ -670,26 +670,31 @@ targetURI = do

670imageKey :: Parser [Char] ParserState (Key, Target)

671imageKey = try $ do

672 string ".. |"

673− ref <- manyTill inline (char '|')

673+ (_,ref) <- withRaw (manyTill inline (char '|'))

674 skipSpaces

675 string "image::"

676 src <- targetURI

677− return (toKey (normalizeSpaces ref), (src, ""))

677+ return (toKey $ init ref, (src, ""))

678

679anonymousKey :: Parser [Char] st (Key, Target)

680anonymousKey = try $ do

681 oneOfStrings [".. __:", "__"]

682 src <- targetURI

683 pos <- getPosition

684− return (toKey [Str $ "_" ++ printf "%09d" (sourceLine pos)], (src, ""))

684+ return (toKey $ "_" ++ printf "%09d" (sourceLine pos), (src, ""))

685+

686+stripTicks :: String -> String

687+stripTicks = reverse . stripTick . reverse . stripTick

688+ where stripTick ('`':xs) = xs

689+ stripTick xs = xs

685

690

686regularKey :: Parser [Char] ParserState (Key, Target)

691regularKey :: Parser [Char] ParserState (Key, Target)

687regularKey = try $ do

692regularKey = try $ do

688 string ".. _"

693 string ".. _"

689− ref <- referenceName

694+ (_,ref) <- withRaw referenceName

690 char ':'

695 char ':'

691 src <- targetURI

696 src <- targetURI

692− return (toKey (normalizeSpaces ref), (src, ""))

697+ return (toKey $ stripTicks ref, (src, ""))

693

698

694--

699--

695-- tables

700-- tables

@@ -921,19 +926,19 @@ explicitLink = try $ do

921

926

922referenceLink :: Parser [Char] ParserState Inline

927referenceLink :: Parser [Char] ParserState Inline

923referenceLink = try $ do

928referenceLink = try $ do

924− label' <- (quotedReferenceName <|> simpleReferenceName) >>~ char '_'

929+ (label',ref) <- withRaw (quotedReferenceName <|> simpleReferenceName) >>~

930+ char '_'

925 state <- getState

931 state <- getState

926 let keyTable = stateKeys state

932 let keyTable = stateKeys state

927− let isAnonKey x = case fromKey x of

933+ let isAnonKey (Key ('_':_)) = True

928− [Str ('_':_)] -> True

929− _ -> False

934+ isAnonKey _ = False

930− key <- option (toKey label') $

935+ key <- option (toKey $ stripTicks ref) $

931 do char '_'

936 do char '_'

932 let anonKeys = sort $ filter isAnonKey $ M.keys keyTable

937 let anonKeys = sort $ filter isAnonKey $ M.keys keyTable

933 if null anonKeys

938 if null anonKeys

934 then mzero

939 then mzero

935 else return (head anonKeys)

940 else return (head anonKeys)

936− (src,tit) <- case lookupKeySrc keyTable key of

941+ (src,tit) <- case M.lookup key keyTable of

937 Nothing -> fail "no corresponding key"

942 Nothing -> fail "no corresponding key"

938 Just target -> return target

943 Just target -> return target

939 -- if anonymous link, remove key so it won't be used again

944 -- if anonymous link, remove key so it won't be used again

@@ -957,13 +962,13 @@ autoLink = autoURI <|> autoEmail

957image :: Parser [Char] ParserState Inline

962image :: Parser [Char] ParserState Inline

958image = try $ do

963image = try $ do

959 char '|'

964 char '|'

960− ref <- manyTill inline (char '|')

965+ (alt,ref) <- withRaw (manyTill inline (char '|'))

961 state <- getState

966 state <- getState

962 let keyTable = stateKeys state

967 let keyTable = stateKeys state

963− (src,tit) <- case lookupKeySrc keyTable (toKey ref) of

968+ (src,tit) <- case M.lookup (toKey $ init ref) keyTable of

964 Nothing -> fail "no corresponding key"

969 Nothing -> fail "no corresponding key"

965 Just target -> return target

970 Just target -> return target

966− return $ Image (normalizeSpaces ref) (src, tit)

971+ return $ Image (normalizeSpaces alt) (src, tit)

967

972

968note :: Parser [Char] ParserState Inline

973note :: Parser [Char] ParserState Inline

969note = try $ do

974note = try $ do