Allow fenced code blocks interrupt paragraphs

CHANGELOG.md

@@ -1,3 +1,7 @@
+## MMark 0.0.3.0
+
+* Code can interrupt paragraphs now, as per Common Mark spec.
+
 ## MMark 0.0.2.1
 
 * Improved performance of the parser. Mainly the inline-level parser to be

README.md

@@ -174,8 +174,6 @@ do, the closing `*` won't be in right-flanking position anymore. God dammit.
 
 Block-level parsing:
 
-* Code blocks should be separated from paragraphs and lists by at least one
-  empty line.
 * If a line starts with hash signs it is expected to be a valid *non-empty*
   header (level 1–6 inclusive). If you want to start a paragraph with
   hashes, just escape the first hash with backslash and that will be enough.

Text/MMark/Parser.hs

@@ -334,33 +334,42 @@ pAtxHeading = do
 
 pFencedCodeBlock :: BParser (Block Isp)
 pFencedCodeBlock = do
-  let p ch = try $ do
-        void $ count 3 (char ch)
-        n  <- (+ 3) . length <$> many (char ch)
-        ml <- optional
-          (T.strip <$> someEscapedWith notNewline <?> "info string")
-        guard (maybe True (not . T.any (== '`')) ml)
-        return
-          (ch, n,
-             case ml of
-               Nothing -> Nothing
-               Just l  ->
-                 if T.null l
-                   then Nothing
-                   else Just l)
   alevel <- L.indentLevel
-  (ch, n, infoString) <- (p '`' <|> p '~') <* eol
+  (ch, n, infoString) <- pOpeningFence
   let content = label "code block content" (option "" nonEmptyLine <* eol)
-      closingFence = try . label "closing code fence" $ do
-        clevel <- ilevel <$> asks benvRefLevel
-        void $ L.indentGuard sc' LT clevel
-        void $ count n (char ch)
-        (void . many . char) ch
-        sc'
-        eof <|> eol
-  ls <- manyTill content closingFence
+  ls <- manyTill content (pClosingFence ch n)
   CodeBlock infoString (assembleCodeBlock alevel ls) <$ sc
 
+-- | Parse the opening fence of a fenced code block.
+
+pOpeningFence :: BParser (Char, Int, Maybe Text)
+pOpeningFence = p '`' <|> p '~'
+  where
+    p ch = try $ do
+      void $ count 3 (char ch)
+      n  <- (+ 3) . length <$> many (char ch)
+      ml <- optional
+        (T.strip <$> someEscapedWith notNewline <?> "info string")
+      guard (maybe True (not . T.any (== '`')) ml)
+      (ch, n,
+         case ml of
+           Nothing -> Nothing
+           Just l  ->
+             if T.null l
+               then Nothing
+               else Just l) <$ eol
+
+-- | Parse the closing fence of a fenced code block.
+
+pClosingFence :: Char -> Int -> BParser ()
+pClosingFence ch n =  try . label "closing code fence" $ do
+  clevel <- ilevel <$> asks benvRefLevel
+  void $ L.indentGuard sc' LT clevel
+  void $ count n (char ch)
+  (void . many . char) ch
+  sc'
+  eof <|> eol
+
 -- | Parse an indented code block.
 
 pIndentedCodeBlock :: BParser (Block Isp)
@@ -532,6 +541,7 @@ pParagraph = do
             [ void (char '>')
             , void pThematicBreak
             , void pAtxHeading
+            , void pOpeningFence
             , void (pListBullet Nothing)
             , void (pListIndex  Nothing) ]
         if isBlank l

tests/Text/MMarkSpec.hs

@@ -221,7 +221,7 @@ spec = parallel $ do
       it "CM94" $
         let s = "```"
         in s ~-> err (posN 3 s)
-           (ueof <> etok '`' <> elabel "info string" <> elabel "newline")
+           (ueib <> etok '`' <> elabel "code span content")
       it "CM95" $
         let s = "`````\n\n```\naaa\n"
         in s ~-> err (posN 15 s)
@@ -266,7 +266,7 @@ spec = parallel $ do
            (ueof <> elabel "closing code fence" <> elabel "code block content")
       it "CM108" $
         "foo\n```\nbar\n```\nbaz" ==->
-          "<p>foo\n<code>bar</code>\nbaz</p>\n"
+          "<p>foo</p>\n<pre><code>bar\n</code></pre>\n<p>baz</p>\n"
       xit "CM109" $ -- FIXME pending setext headings
         "foo\n---\n~~~\nbar\n~~~\n# baz" ==->
           "<h2>foo</h2>\n<pre><code>bar\n</code></pre>\n<h1>baz</h1>\n"