Destroy Data.Attoparsec.Parsable; use Data.Default instead

[Lucu.git] / Network / HTTP / Lucu / MIMEParams.hs

diff --git a/Network/HTTP/Lucu/MIMEParams.hs b/Network/HTTP/Lucu/MIMEParams.hs
index fcfee9e36f43737b426e0f4e20d8b0ab03905908..e4e4271a6fcdd405b25804c113778f4158ae344a 100644 (file)
--- a/Network/HTTP/Lucu/MIMEParams.hs
+++ b/Network/HTTP/Lucu/MIMEParams.hs
@@ -16,8 +16,6 @@
 -- (<http://tools.ietf.org/html/rfc2231>).
 module Network.HTTP.Lucu.MIMEParams
     ( MIMEParams
-    , printMIMEParams
-    , mimeParams
     )
     where
 import Control.Applicative hiding (empty)
@@ -32,6 +30,10 @@ import Data.Char
 import Data.Collections
 import Data.Collections.BaseInstances ()
 import qualified Data.Collections.Newtype.TH as C
+import Data.Convertible.Base
+import Data.Convertible.Instances.Ascii ()
+import Data.Convertible.Utils
+import Data.Default
 import qualified Data.Map as M (Map)
 import Data.Monoid.Unicode
 import Data.Sequence (Seq)
@@ -55,14 +57,17 @@ C.derive [d| instance Unfoldable MIMEParams (CIAscii, Text)
              instance SortingCollection MIMEParams (CIAscii, Text)
            |]
 
--- |Convert MIME parameter values to an 'AsciiBuilder'.
-printMIMEParams ∷ MIMEParams → AsciiBuilder
-{-# INLINEABLE printMIMEParams #-}
-printMIMEParams = foldl' f (∅)
-    where
-      f ∷ AsciiBuilder → (CIAscii, Text) → AsciiBuilder
-      {-# INLINE f #-}
-      f ab (k, v) = ab ⊕ A.toAsciiBuilder "; " ⊕ printPair k v
+instance ConvertSuccess MIMEParams Ascii where
+    {-# INLINE convertSuccess #-}
+    convertSuccess = convertSuccessVia ((⊥) ∷ AsciiBuilder)
+
+instance ConvertSuccess MIMEParams AsciiBuilder where
+    {-# INLINEABLE convertSuccess #-}
+    convertSuccess = foldl' f (∅)
+        where
+          f ∷ AsciiBuilder → (CIAscii, Text) → AsciiBuilder
+          {-# INLINE f #-}
+          f ab (k, v) = ab ⊕ cs ("; " ∷ Ascii) ⊕ printPair k v
 
 printPair ∷ CIAscii → Text → AsciiBuilder
 {-# INLINEABLE printPair #-}
@@ -75,19 +80,19 @@ printPair name value
 printPairInUTF8 ∷ CIAscii → Text → AsciiBuilder
 {-# INLINEABLE printPairInUTF8 #-}
 printPairInUTF8 name value
-    = A.toAsciiBuilder (A.fromCIAscii name) ⊕
-      A.toAsciiBuilder "*=utf-8''" ⊕
+    = cs name ⊕
+      cs ("*=utf-8''" ∷ Ascii) ⊕
       escapeUnsafeChars (encodeUtf8 value) (∅)
 
 printPairInAscii ∷ CIAscii → Ascii → AsciiBuilder
 {-# INLINEABLE printPairInAscii #-}
 printPairInAscii name value
-    = A.toAsciiBuilder (A.fromCIAscii name) ⊕
-      A.toAsciiBuilder "=" ⊕
-      if BS.any ((¬) ∘ isToken) (A.toByteString value) then
+    = cs name ⊕
+      cs ("=" ∷ Ascii) ⊕
+      if BS.any ((¬) ∘ isToken) (cs value) then
           quoteStr value
       else
-          A.toAsciiBuilder value
+          cs value
 
 escapeUnsafeChars ∷ BS.ByteString → AsciiBuilder → AsciiBuilder
 {-# INLINEABLE escapeUnsafeChars #-}
@@ -96,15 +101,15 @@ escapeUnsafeChars bs b
         Nothing         → b
         Just (c, bs')
             | isToken c → escapeUnsafeChars bs' $
-                          b ⊕ A.toAsciiBuilder (A.unsafeFromString [c])
+                          b ⊕ cs (A.unsafeFromString [c])
             | otherwise → escapeUnsafeChars bs' $
                           b ⊕ toHex (fromIntegral $ fromEnum c)
 
 toHex ∷ Word8 → AsciiBuilder
 {-# INLINEABLE toHex #-}
-toHex o = A.toAsciiBuilder "%" ⊕
-          A.toAsciiBuilder (A.unsafeFromString [ toHex' (o `shiftR` 8)
-                                               , toHex' (o .&.   0x0F) ])
+toHex o = cs ("%" ∷ Ascii) ⊕
+          cs (A.unsafeFromString [ toHex' (o `shiftR` 8)
+                                 , toHex' (o .&.   0x0F) ])
     where
       toHex' ∷ Word8 → Char
       {-# INLINEABLE toHex' #-}
@@ -114,6 +119,10 @@ toHex o = A.toAsciiBuilder "%" ⊕
           | otherwise = toEnum $ fromIntegral
                                $ fromEnum 'A' + fromIntegral (h - 0x0A)
 
+deriveAttempts [ ([t| MIMEParams |], [t| Ascii        |])
+               , ([t| MIMEParams |], [t| AsciiBuilder |])
+               ]
+
 data ExtendedParam
     = InitialEncodedParam {
         epName    ∷ !CIAscii
@@ -136,34 +145,33 @@ section ∷ ExtendedParam → Integer
 section (InitialEncodedParam {..}) = 0
 section ep                         = epSection ep
 
--- |'Parser' for MIME parameter values.
-mimeParams ∷ Parser MIMEParams
-{-# INLINEABLE mimeParams #-}
-mimeParams = decodeParams =≪ many (try paramP)
+instance Default (Parser MIMEParams) where
+    {-# INLINE def #-}
+    def = decodeParams =≪ many (try def)
 
-paramP ∷ Parser ExtendedParam
-paramP = do skipMany lws
-            void $ char ';'
-            skipMany lws
-            epm ← nameP
-            void $ char '='
-            case epm of
-              (name, 0, True)
-                  → do (charset, payload) ← initialEncodedValue
-                       return $ InitialEncodedParam name charset payload
-              (name, sect, True)
-                  → do payload ← encodedPayload
-                       return $ ContinuedEncodedParam name sect payload
-              (name, sect, False)
-                  → do payload ← token <|> quotedStr
-                       return $ AsciiParam name sect payload
+instance Default (Parser ExtendedParam) where
+    def = do skipMany lws
+             void $ char ';'
+             skipMany lws
+             epm ← name
+             void $ char '='
+             case epm of
+               (nm, 0, True)
+                   → do (charset, payload) ← initialEncodedValue
+                        return $ InitialEncodedParam nm charset payload
+               (nm, sect, True)
+                   → do payload ← encodedPayload
+                        return $ ContinuedEncodedParam nm sect payload
+               (nm, sect, False)
+                   → do payload ← token <|> quotedStr
+                        return $ AsciiParam nm sect payload
 
-nameP ∷ Parser (CIAscii, Integer, Bool)
-nameP = do name      ← (A.toCIAscii ∘ A.unsafeFromByteString) <$>
-                       takeWhile1 (\c → isToken c ∧ c ≢ '*')
-           sect      ← option 0     $ try (char '*' *> decimal  )
-           isEncoded ← option False $ try (char '*' *> pure True)
-           return (name, sect, isEncoded)
+name ∷ Parser (CIAscii, Integer, Bool)
+name = do nm        ← (cs ∘ A.unsafeFromByteString) <$>
+                      takeWhile1 (\c → isToken c ∧ c ≢ '*')
+          sect      ← option 0     $ try (char '*' *> decimal  )
+          isEncoded ← option False $ try (char '*' *> pure True)
+          return (nm, sect, isEncoded)
 
 initialEncodedValue ∷ Parser (CIAscii, BS.ByteString)
 initialEncodedValue
@@ -181,7 +189,7 @@ initialEncodedValue
              return (charset, payload)
     where
       metadata ∷ Parser CIAscii
-      metadata = (A.toCIAscii ∘ A.unsafeFromByteString) <$>
+      metadata = (cs ∘ A.unsafeFromByteString) <$>
                  takeWhile (\c → c ≢ '\'' ∧ isToken c)
 
 encodedPayload ∷ Parser BS.ByteString
@@ -248,7 +256,7 @@ sortBySection = flip go (∅)
                            → fail (concat [ "Duplicate section "
                                           , show $ section x
                                           , " for parameter '"
-                                          , A.toString $ A.fromCIAscii $ epName x
+                                          , cs $ epName x
                                           , "'"
                                           ])
 
@@ -271,7 +279,7 @@ decodeSections = (decodeSeq =≪) ∘ flip (flip toSeq 0) (∅)
                         → fail (concat [ "Missing section "
                                        , show $ section p
                                        , " for parameter '"
-                                       , A.toString $ A.fromCIAscii $ epName p
+                                       , cs $ epName p
                                        , "'"
                                        ])
 
@@ -287,9 +295,7 @@ decodeSections = (decodeSeq =≪) ∘ flip (flip toSeq 0) (∅)
               Just (ContinuedEncodedParam {..}, _)
                   → fail "decodeSeq: internal error: CEP at section 0"
               Just (AsciiParam {..}, xs)
-                  → let t = A.toText apPayload
-                    in
-                      decodeSeq' Nothing xs $ singleton t
+                  → decodeSeq' Nothing xs $ singleton $ cs apPayload
 
       decodeSeq' ∷ Monad m
                  ⇒ Maybe Decoder
@@ -311,13 +317,11 @@ decodeSections = (decodeSeq =≪) ∘ flip (flip toSeq 0) (∅)
                            → fail (concat [ "Section "
                                           , show epSection
                                           , " for parameter '"
-                                          , A.toString $ A.fromCIAscii epName
+                                          , cs epName
                                           , "' is encoded but its first section is not"
                                           ])
               Just (AsciiParam {..}, xs)
-                  → let t = A.toText apPayload
-                    in
-                      decodeSeq' decoder xs $ chunks ⊳ t
+                  → decodeSeq' decoder xs $ chunks ⊳ cs apPayload
 
 type Decoder = BS.ByteString → Either UnicodeException Text
 
@@ -331,5 +335,4 @@ getDecoder ∷ Monad m ⇒ CIAscii → m Decoder
 getDecoder charset
     | charset ≡ "UTF-8"    = return decodeUtf8'
     | charset ≡ "US-ASCII" = return decodeUtf8'
-    | otherwise            = fail $ "No decoders found for charset: "
-                                  ⧺ A.toString (A.fromCIAscii charset)
+    | otherwise            = fail $ "No decoders found for charset: " ⊕ cs charset