Add escaped characters

Author: Simre1

Readme.md

@@ -60,7 +60,7 @@ Here, I have used the `neorg-pandoc-linux86` binary to transform my `norg` file
   - @image :x:
   - Custom :x:
 - Trailing modifiers :heavy_check_mark:
-- Escaping :x:
+- Escaping :heavy_check_mark:
 - Horizontal line :heavy_check_mark: 
 - Links :x:
 

src/Neorg/Parser.hs

@@ -289,14 +289,14 @@ paragraph' end' = do
       modify $ modifierInline .~ new
       where
         close (NoModifier b) = fail "No closing"
-        close (OpenModifier cm i b) = 
+        close (OpenModifier cm i b) =
           case b of
             (OpenModifier cd id bd) -> if c == cm then pure (OpenModifier cd (id <> f i) bd) else close (OpenModifier cd (id <> Text cm <> i) bd)
             (NoModifier id) -> if c == cm then pure (NoModifier (id <> f i)) else fail "No closing"
     pushStack :: Text -> StateT InlineState p ()
     pushStack c = do
       s <- gets (view modifierInline)
-      new <-  case s of
+      new <- case s of
         NoModifier i -> pure $ OpenModifier c mempty (NoModifier i)
         stack@(OpenModifier cm i b) ->
           if not $ hasModifier c stack
@@ -337,8 +337,8 @@ paragraph' end' = do
       where
         follow =
           singleSpace <|> newline
-              <|> withNextChar
-                (guard . flip S.member (punctuationSymbols <> attachedModifierSymbols))
+            <|> withNextChar
+              (guard . flip S.member (punctuationSymbols <> attachedModifierSymbols))
         parseOpening c = do
           P.try $ do
             anyChar >> withNextChar (\c -> guard $ isLetter c || S.member c specialSymbols)
@@ -374,17 +374,31 @@ paragraph' end' = do
       modify (delimitedActive .~ False)
       if S.member c (punctuationSymbols <> attachedModifierSymbols)
         then
-          ( do
-              p <- lift anyChar <&> pack . (: [])
-              appendInlineToStack (Text p)
-              withNextChar $ \c -> parWhitespace c <|> attachedClosings c <|> attachedOpenings c <|> word c
+          ( P.try
+              ( do
+                  guard (c == '\\')
+                  a <- anyChar >> anyChar
+                  guard (a > ' ')
+                  pure a
+              )
+              >>= \x -> do
+                appendInlineToStack
+                  (Text $ pack [x])
+                withNextChar $
+                  \c -> parWhitespace c <|> attachedClosings c <|> word c
           )
+            <|> ( do
+                    p <- lift anyChar <&> pack . (: [])
+                    appendInlineToStack (Text p)
+                    withNextChar $ \c -> parWhitespace c <|> attachedClosings c <|> attachedOpenings c <|> word c
+                )
         else
           ( do
               w <- P.takeWhile1P (Just "Word") (\c -> c > ' ' && S.notMember c (punctuationSymbols <> attachedModifierSymbols))
               appendInlineToStack (Text w)
               withNextChar $ \c -> parWhitespace c <|> attachedClosings c <|> word c
           )
+
     punctuationSymbols = S.fromList "?!:;,.<>()[]{}'\"/#%&$£€-*\\~"
     attachedModifierSymbols = S.fromList "*/_-^,|`$="
 
@@ -396,7 +410,7 @@ paragraph' end' = do
     intersectingModifier :: Char -> StateT InlineState p ()
     intersectingModifier c1 = do
       c2 <- followedBy $ anyChar >> anyChar
-      case c1:[c2] of
+      case c1 : [c2] of
         ":*" -> intersectingOpen ":*"
         ":/" -> intersectingOpen ":/"
         ":_" -> intersectingOpen ":_"
@@ -406,7 +420,6 @@ paragraph' end' = do
         ":|" -> intersectingOpen ":|"
         ":`" -> parseTextModifier (pure ()) ":`" Verbatim
         ":$" -> parseTextModifier (pure ()) ":$" Math
-
         "*:" -> intersectingClosed ":*" Bold
         "/:" -> intersectingClosed ":/" Italic
         "_:" -> intersectingClosed ":_" Underline

test/Parser.hs

@@ -133,7 +133,8 @@ paragraphTests =
       testCase "Single-Line intersecting Subscript" $ parse singleLineParagraph ":,sub,:" @?= Subscript (Text "sub"),
       testCase "Single-Line intersecting Spoiler" $ parse singleLineParagraph ":|spoiler|:" @?= Spoiler (Text "spoiler"),
       testCase "Single-Line intersecting Math" $ parse singleLineParagraph ":$math$:" @?= Math "math",
-      testCase "Single-Line intersecting Verbatim" $ parse singleLineParagraph ":`verbatim`:" @?= Verbatim "verbatim"
+      testCase "Single-Line intersecting Verbatim" $ parse singleLineParagraph ":`verbatim`:" @?= Verbatim "verbatim",
+      testCase "Escape bold character" $ parse singleLineParagraph "\\*test*" @?= Text "*test*"
     ]
 
 markerTests :: TestTree
@@ -235,7 +236,14 @@ listTests =
                             V.singleton $ ListParagraph (Text "l2")
                           ]
                     }
-            ]
+            ],
+      testCase "Escaped list" $
+        parse (blocks @Empty) "\\- test1"
+          @?= V.singleton
+            ( Paragraph
+                ( ConcatInline $ V.fromList [Text "-", Space, Text "test1"]
+                )
+            )
     ]
 
 headingTests :: TestTree