, TypeSynonymInstances
, UnicodeSyntax
#-}
-{-# OPTIONS_GHC -ddump-splices #-} -- FIXME
--- GHC 7.0.3 gives us a false warning.
+{-# OPTIONS_GHC -fno-warn-orphans #-}
{-# OPTIONS_GHC -fno-warn-missing-methods #-}
-- |Parsing and printing MIME parameter values
-- (<http://tools.ietf.org/html/rfc2231>).
module Network.HTTP.Lucu.MIMEParams
( MIMEParams
- , printMIMEParams
- , mimeParams
)
where
import Control.Applicative hiding (empty)
-import Control.Arrow
import Control.Monad hiding (mapM)
import Control.Monad.Unicode
import Data.Ascii (Ascii, CIAscii, AsciiBuilder)
import qualified Data.Ascii as A
-import Data.Attoparsec.Char8 as P
+import Data.Attoparsec.Char8
import Data.Bits
import qualified Data.ByteString.Char8 as BS
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
import Data.Monoid.Unicode
import Data.Sequence (Seq)
import Data.Text (Text)
import qualified Data.Text as T
import Data.Text.Encoding
import Data.Text.Encoding.Error
-import Data.Typeable
import Data.Word
+import Network.HTTP.Lucu.MIMEParams.Internal
import Network.HTTP.Lucu.OrphanInstances ()
import Network.HTTP.Lucu.Parser.Http
import Network.HTTP.Lucu.Utils
-import Prelude hiding (concat, filter, foldr, lookup, mapM, null, takeWhile)
+import Prelude hiding (concat, lookup, mapM, takeWhile)
import Prelude.Unicode
--- |A 'Map' from MIME parameter attributes to values. Attributes are
--- always case-insensitive according to RFC 2045
--- (<http://tools.ietf.org/html/rfc2045#section-5.1>).
-newtype MIMEParams
- = MIMEParams (M.Map CIAscii Text)
- deriving (Eq, Show, Read, Monoid, Typeable)
-
C.derive [d| instance Unfoldable MIMEParams (CIAscii, Text)
instance Foldable MIMEParams (CIAscii, Text)
+ instance Collection MIMEParams (CIAscii, Text)
+ instance Indexed MIMEParams CIAscii Text
+ instance Map MIMEParams CIAscii Text
+ instance SortingCollection MIMEParams (CIAscii, Text)
|]
--- FIXME: auto-derive
-instance Collection MIMEParams (CIAscii, Text) where
- {-# INLINE filter #-}
- filter f (MIMEParams m) = MIMEParams $ filter f m
-
--- FIXME: auto-derive
-instance Indexed MIMEParams CIAscii Text where
- {-# INLINE index #-}
- index k (MIMEParams m) = index k m
- {-# INLINE adjust #-}
- adjust f k (MIMEParams m) = MIMEParams $ adjust f k m
- {-# INLINE inDomain #-}
- inDomain k (MIMEParams m) = inDomain k m
-
--- FIXME: auto-derive
-instance Map MIMEParams CIAscii Text where
- {-# INLINE lookup #-}
- lookup k (MIMEParams m) = lookup k m
- {-# INLINE mapWithKey #-}
- mapWithKey f (MIMEParams m)
- = MIMEParams $ mapWithKey f m
- {-# INLINE unionWith #-}
- unionWith f (MIMEParams α) (MIMEParams β)
- = MIMEParams $ unionWith f α β
- {-# INLINE intersectionWith #-}
- intersectionWith f (MIMEParams α) (MIMEParams β)
- = MIMEParams $ intersectionWith f α β
- {-# INLINE differenceWith #-}
- differenceWith f (MIMEParams α) (MIMEParams β)
- = MIMEParams $ differenceWith f α β
- {-# INLINE isSubmapBy #-}
- isSubmapBy f (MIMEParams α) (MIMEParams β)
- = isSubmapBy f α β
- {-# INLINE isProperSubmapBy #-}
- isProperSubmapBy f (MIMEParams α) (MIMEParams β)
- = isProperSubmapBy f α β
+instance ConvertSuccess MIMEParams Ascii where
+ {-# INLINE convertSuccess #-}
+ convertSuccess = convertSuccessVia ((⊥) ∷ AsciiBuilder)
--- FIXME: auto-derive
-instance SortingCollection MIMEParams (CIAscii, Text) where
- {-# INLINE minView #-}
- minView (MIMEParams m) = second MIMEParams <$> minView m
-
--- |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 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 #-}
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 #-}
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' #-}
| otherwise = toEnum $ fromIntegral
$ fromEnum 'A' + fromIntegral (h - 0x0A)
+deriveAttempts [ ([t| MIMEParams |], [t| Ascii |])
+ , ([t| MIMEParams |], [t| AsciiBuilder |])
+ ]
+
data ExtendedParam
= InitialEncodedParam {
epName ∷ !CIAscii
section (InitialEncodedParam {..}) = 0
section ep = epSection ep
--- |'Parser' for MIME parameter values.
-mimeParams ∷ Parser MIMEParams
-{-# INLINEABLE mimeParams #-}
-mimeParams = decodeParams =≪ P.many (try paramP)
-
-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
-
-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)
+instance Default (Parser MIMEParams) where
+ {-# INLINE def #-}
+ def = decodeParams =≪ many (try def)
+
+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
+
+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
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
{-# INLINE encodedPayload #-}
-encodedPayload = BS.concat <$> P.many (hexChar <|> rawChars)
+encodedPayload = BS.concat <$> many (hexChar <|> rawChars)
hexChar ∷ Parser BS.ByteString
{-# INLINEABLE hexChar #-}
→ fail (concat [ "Duplicate section "
, show $ section x
, " for parameter '"
- , A.toString $ A.fromCIAscii $ epName x
+ , cs $ epName x
, "'"
])
→ fail (concat [ "Missing section "
, show $ section p
, " for parameter '"
- , A.toString $ A.fromCIAscii $ epName p
+ , cs $ epName p
, "'"
])
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
→ 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
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
projects / Lucu.git / blobdiff