Support commas in structure strings (#15)

Author: AntoineGagne

package.yaml

@@ -1,8 +1,9 @@
 name: parthenon
 version: 0.1.1
-synopsis: Athena Structure Parser
+synopsis: AWS Athena Parser
 description:
-    Please see the README on GitHub at <https://github.com/AntoineGagne/parthenon#readme>
+  A parser for AWS Athena schemas and terms.
+category: Development
 homepage: https://github.com/AntoineGagne/parthenon-hs
 github: "AntoineGagne/parthenon-hs"
 license: BSD3

parthenon.cabal

@@ -6,8 +6,9 @@ cabal-version: 2.0
 
 name:           parthenon
 version:        0.1.1
-synopsis:       Athena Structure Parser
-description:    Please see the README on GitHub at <https://github.com/AntoineGagne/parthenon#readme>
+synopsis:       AWS Athena Parser
+description:    A parser for AWS Athena schemas and terms.
+category:       Development
 homepage:       https://github.com/AntoineGagne/parthenon-hs
 bug-reports:    https://github.com/AntoineGagne/parthenon-hs/issues
 author:         Antoine Gagné

src/Parthenon/Decoder.hs

@@ -6,14 +6,15 @@ module Parthenon.Decoder
     bigInt,
     array,
     struct,
-    specialString,
+    structString,
     Athena (..),
   )
 where
 
 import Control.Monad.Combinators
 import Data.Functor (($>))
 import Data.Text (Text)
+import qualified Data.Text as Text
 import Data.Void
 import Parthenon.Types (Athena (..))
 import Text.Megaparsec
@@ -31,7 +32,7 @@ struct entries' =
     struct' = between leftBrace rightBrace entries
 
     entries :: Parser [(Text, Athena)]
-    entries = (choice decoders <|> unknownDecoder) `sepBy` comma
+    entries = (try (choice decoders) <|> unknownDecoder) `sepBy` comma
 
     decoders :: [Parser (Text, Athena)]
     decoders = map decoder entries'
@@ -47,7 +48,7 @@ struct entries' =
     unknownDecoder = do
       key' <- key
       _ <- equal
-      schema' <- try string
+      schema' <- try structString
       pure (key', schema')
 
     key :: Parser Text
@@ -62,8 +63,24 @@ array decoder' = null' <|> (AArray <$> array')
     array' :: Parser [Athena]
     array' = between leftSquare rightSquare (decoder' `sepBy` comma)
 
-specialString :: Parser Athena
-specialString = null'
+structString :: Parser Athena
+structString = null' <|> AString <$> characters
+  where
+    characters :: Parser Text
+    characters = do
+      input <- getInput
+      let n = case (Text.findIndex (== '=') input, Text.findIndex (== '}') input) of
+            (Nothing, Nothing) -> 0
+            (Just _, Nothing) -> 0
+            (Nothing, Just n') -> n'
+            (Just m, Just n')
+              | m < n' ->
+                let untilEqual = Text.take m input
+                    (taken', _) = Text.breakOnEnd "," untilEqual
+                 in Text.length taken' - 1
+            (Just _, Just n') ->
+              n' - 1
+      takeP (Just "characters") n
 
 string :: Parser Athena
 string = null' <|> (AString <$> characters)

src/Parthenon/Schema.hs

@@ -34,26 +34,50 @@ struct = do
     keyValue = do
       key <- characters
       _ <- symbol ":"
-      decoder <- encoder
+      decoder <- structEncoder
       pure (key, decoder)
 
+structEncoder :: Parser (Parser Athena)
+structEncoder =
+  try
+    ( integer
+        <|> bigInt
+        <|> boolean
+        <|> double
+        <|> string
+        <|> struct
+        <|> array
+    )
+  where
+    string :: Parser (Parser Athena)
+    string = symbol "string" $> Decoder.structString
+
 encoder :: Parser (Parser Athena)
-encoder = try (integer <|> bigInt <|> boolean <|> double <|> string <|> struct <|> array)
+encoder =
+  try
+    ( integer
+        <|> bigInt
+        <|> boolean
+        <|> double
+        <|> string
+        <|> struct
+        <|> array
+    )
   where
     string :: Parser (Parser Athena)
     string = symbol "string" $> Decoder.string
 
-    integer :: Parser (Parser Athena)
-    integer = symbol "int" $> Decoder.integer
+integer :: Parser (Parser Athena)
+integer = symbol "int" $> Decoder.integer
 
-    bigInt :: Parser (Parser Athena)
-    bigInt = symbol "bigint" $> Decoder.bigInt
+bigInt :: Parser (Parser Athena)
+bigInt = symbol "bigint" $> Decoder.bigInt
 
-    double :: Parser (Parser Athena)
-    double = symbol "double" $> Decoder.double
+double :: Parser (Parser Athena)
+double = symbol "double" $> Decoder.double
 
-    boolean :: Parser (Parser Athena)
-    boolean = symbol "boolean" $> Decoder.boolean
+boolean :: Parser (Parser Athena)
+boolean = symbol "boolean" $> Decoder.boolean
 
 betweenAngleBrackets :: Parser a -> Parser a
 betweenAngleBrackets = between leftAngle rightAngle

test/Parthenon/DecoderSpec.hs

@@ -189,10 +189,10 @@ spec = parallel $ do
                 )
               ]
           )
-    xit "can decode a struct with string that contain commas, spaces and special characters" $
+    it "can decode a struct with string that contain commas, spaces and special characters" $
       parseMaybe
         ( Decoder.struct
-            [ ("a", Decoder.string)
+            [ ("a", Decoder.structString)
             ]
         )
         "{a = Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/51.0.2704.103 Safari/537.36}"
@@ -203,10 +203,10 @@ spec = parallel $ do
                 )
               ]
           )
-    xit "can decode a struct with multiple fields with string that contain commas, spaces and special characters" $
+    it "can decode a struct with multiple fields with string that contain commas, spaces and special characters" $
       parseMaybe
         ( Decoder.struct
-            [ ("a", Decoder.string),
+            [ ("a", Decoder.structString),
               ("b", Decoder.integer)
             ]
         )

test/Parthenon/SchemaSpec.hs

@@ -73,6 +73,45 @@ spec = parallel $ do
                 )
               ]
           )
+    it "can decode a struct with string that contains commas" $
+      parseMaybe
+        "struct<b:string>"
+        "{b=foo bar, jane smith}"
+        `shouldBe` Just
+          ( AStruct
+              [ ("b", AString "foo bar, jane smith")
+              ]
+          )
+    it "can decode a struct with string that contains commas and unknown keys" $
+      parseMaybe
+        "struct<b:string>"
+        "{a=123, b=foo bar, jane smith, c=123, d=true, e=-2.0}"
+        `shouldBe` Just
+          ( AStruct
+              [ ("a", AString "123"),
+                ("b", AString "foo bar, jane smith"),
+                ("c", AString "123"),
+                ("d", AString "true"),
+                ("e", AString "-2.0")
+              ]
+          )
+    it "can decode a nested struct with string that contains commas and unknown keys" $
+      parseMaybe
+        "struct<a:struct<b:string>>"
+        "{a={a=123, b=foo bar, jane smith, c=123, d=true, e=-2.0}}"
+        `shouldBe` Just
+          ( AStruct
+              [ ( "a",
+                  AStruct
+                    [ ("a", AString "123"),
+                      ("b", AString "foo bar, jane smith"),
+                      ("c", AString "123"),
+                      ("d", AString "true"),
+                      ("e", AString "-2.0")
+                    ]
+                )
+              ]
+          )
 
 parseMaybe :: Text -> Text -> Maybe Athena
 parseMaybe rawSchema input = do