More sane Yesod.Request lookup functions

Yesod/Form.hs

@@ -63,15 +63,18 @@ runFormPost :: (RequestReader m, Failure ErrorResponse m, MonadIO m)
             => Form x -> m x
 runFormPost f = do
     rr <- getRequest
-    pp <- postParams rr
+    (pp, _) <- liftIO $ reqRequestBody rr
-    runFormGeneric pp f
+    runFormGeneric (flip lookup' pp) f
+
+lookup' :: Eq a => a -> [(a, b)] -> [b]
+lookup' a = map snd . filter (\x -> a == fst x)
 
 -- | Run a form against GET parameters.
 runFormGet :: (RequestReader m, Failure ErrorResponse m)
            => Form x -> m x
 runFormGet f = do
     rr <- getRequest
-    runFormGeneric (getParams rr) f
+    runFormGeneric (flip lookupGetParams rr) f
 
 input :: ParamName -> Form [ParamValue]
 input pn = Form $ \l -> Right (Just pn, l pn)

Yesod/Helpers/Auth.hs

@@ -168,17 +168,14 @@ testOpenId = do
 getOpenIdR :: Yesod master => GHandler Auth master RepHtml
 getOpenIdR = do
     testOpenId
-    rr <- getRequest
+    lookupGetParam "dest" >>= maybe (return ()) setUltDestString
-    case getParams rr "dest" of
-        [] -> return ()
-        (x:_) -> setUltDestString x
     rtom <- getRouteToMaster
     message <- getMessage
     applyLayout "Log in via OpenID" mempty [$hamlet|
 $maybe message msg
     %p.message $msg$
 %form!method=get!action=@rtom.OpenIdForward@
-    %label!for=openid OpenID: 
+    %label!for=openid OpenID: $
     %input#openid!type=text!name=openid
     %input!type=submit!value=Login
 |]
@@ -186,10 +183,7 @@ $maybe message msg
 getOpenIdForward :: GHandler Auth master ()
 getOpenIdForward = do
     testOpenId
-    rr <- getRequest
+    oid <- runFormGet $ required $ input "openid"
-    oid <- case getParams rr "openid" of
-            [x] -> return x
-            _ -> invalidArgs [("openid", "Expected single parameter")]
     render <- getUrlRender
     toMaster <- getRouteToMaster
     let complete = render $ toMaster OpenIdComplete
@@ -224,11 +218,11 @@ handleRpxnowR = do
     apiKey <- case authRpxnowApiKey auth of
                 Just x -> return x
                 Nothing -> notFound
-    rr <- getRequest
+    token1 <- lookupGetParam "token"
-    pp <- postParams rr
+    token2 <- lookupPostParam "token"
-    let token = case getParams rr "token" ++ pp "token" of
+    let token = case token1 `mplus` token2 of
-                    [] -> invalidArgs [("token", "Value not supplied")]
+                    Nothing -> invalidArgs [("token", "Value not supplied")]
-                    (x:_) -> x
+                    Just x -> x
     Rpxnow.Identifier ident extra <- liftIO $ Rpxnow.authenticate apiKey token
     let creds = Creds
                     ident
@@ -238,14 +232,14 @@ handleRpxnowR = do
                     Nothing
                     Nothing
     setCreds creds extra
+    dest1 <- lookupPostParam "dest"
+    dest2 <- lookupGetParam "dest"
     either (redirect RedirectTemporary) (redirectString RedirectTemporary) $
-        case pp "dest" of
+        case dest1 `mplus` dest2 of
-            (d:_) -> Right d
+            Just "" -> Left $ defaultDest ay
-            [] -> case getParams rr "dest" of
+            Nothing -> Left $ defaultDest ay
-                    [] -> Left $ defaultDest ay
+            Just ('#':d) -> Right d
-                    ("":_) -> Left $ defaultDest ay
+            Just d -> Right d
-                    (('#':rest):_) -> Right rest
-                    (s:_) -> Right s
 
 -- | Get some form of a display name.
 getDisplayName :: [(String, String)] -> Maybe String

Yesod/Request.hs

@@ -29,11 +29,13 @@ module Yesod.Request
     , lookupPostParam
     , lookupCookie
     , lookupSession
-      -- ** Alternate
+    , lookupFile
-    , getParams
+      -- ** Multi-lookup
-    , postParams
+    , lookupGetParams
-    , cookies
+    , lookupPostParams
-    , session
+    , lookupCookies
+    , lookupSessions
+    , lookupFiles
       -- * Parameter type synonyms
     , ParamName
     , ParamValue
@@ -46,6 +48,7 @@ import "transformers" Control.Monad.IO.Class
 import Control.Monad (liftM)
 import Network.Wai.Parse
 import Control.Monad.Instances () -- I'm missing the instance Monad ((->) r
+import Data.Maybe (listToMaybe)
 
 type ParamName = String
 type ParamValue = String
@@ -99,59 +102,64 @@ data Request = Request
     , reqLangs :: [String]
     }
 
-multiLookup :: [(ParamName, ParamValue)] -> ParamName -> [ParamValue]
+lookup' :: Eq a => a -> [(a, b)] -> [b]
-multiLookup [] _ = []
+lookup' a = map snd . filter (\x -> a == fst x)
-multiLookup ((k, v):rest) pn
-    | k == pn = v : multiLookup rest pn
-    | otherwise = multiLookup rest pn
 
--- | All GET paramater values with the given name.
+-- | Lookup for GET parameters.
-getParams :: RequestReader m => m (ParamName -> [ParamValue])
+lookupGetParams :: RequestReader m => ParamName -> m [ParamValue]
-getParams = do
+lookupGetParams pn = do
     rr <- getRequest
-    return $ multiLookup $ reqGetParams rr
+    return $ lookup' pn $ reqGetParams rr
 
 -- | Lookup for GET parameters.
 lookupGetParam :: RequestReader m => ParamName -> m (Maybe ParamValue)
-lookupGetParam pn = do
+lookupGetParam = liftM listToMaybe . lookupGetParams
-    rr <- getRequest
-    return $ lookup pn $ reqGetParams rr
-
--- | All POST paramater values with the given name.
-postParams :: MonadIO m => Request -> m (ParamName -> [ParamValue])
-postParams rr = do
-    (pp, _) <- liftIO $ reqRequestBody rr
-    return $ multiLookup pp
 
 -- | Lookup for POST parameters.
+lookupPostParams :: (MonadIO m, RequestReader m)
+                 => ParamName
+                 -> m [ParamValue]
+lookupPostParams pn = do
+    rr <- getRequest
+    (pp, _) <- liftIO $ reqRequestBody rr
+    return $ lookup' pn pp
+
 lookupPostParam :: (MonadIO m, RequestReader m)
                 => ParamName
                 -> m (Maybe ParamValue)
-lookupPostParam pn = do
+lookupPostParam = liftM listToMaybe . lookupPostParams
-    rr <- getRequest
-    (pp, _) <- liftIO $ reqRequestBody rr
-    return $ lookup pn pp
 
--- | All cookies with the given name.
+-- | Lookup for POSTed files.
-cookies :: RequestReader m => m (ParamName -> [ParamValue])
+lookupFile :: (MonadIO m, RequestReader m)
-cookies = do
+           => ParamName
+           -> m (Maybe (FileInfo BL.ByteString))
+lookupFile = liftM listToMaybe . lookupFiles
+
+-- | Lookup for POSTed files.
+lookupFiles :: (MonadIO m, RequestReader m)
+            => ParamName
+            -> m [FileInfo BL.ByteString]
+lookupFiles pn = do
     rr <- getRequest
-    return $ multiLookup $ reqCookies rr
+    (_, files) <- liftIO $ reqRequestBody rr
+    return $ lookup' pn files
 
 -- | Lookup for cookie data.
 lookupCookie :: RequestReader m => ParamName -> m (Maybe ParamValue)
-lookupCookie pn = do
+lookupCookie = liftM listToMaybe . lookupCookies
-    rr <- getRequest
-    return $ lookup pn $ reqCookies rr
 
--- | All session data with the given name.
+-- | Lookup for cookie data.
-session :: RequestReader m => m (ParamName -> [ParamValue])
+lookupCookies :: RequestReader m => ParamName -> m [ParamValue]
-session = do
+lookupCookies pn = do
     rr <- getRequest
-    return $ multiLookup $ reqSession rr
+    return $ lookup' pn $ reqCookies rr
 
 -- | Lookup for session data.
 lookupSession :: RequestReader m => ParamName -> m (Maybe ParamValue)
-lookupSession pn = do
+lookupSession = liftM listToMaybe . lookupSessions
+
+-- | Lookup for session data.
+lookupSessions :: RequestReader m => ParamName -> m [ParamValue]
+lookupSessions pn = do
     rr <- getRequest
-    return $ lookup pn $ reqSession rr
+    return $ lookup' pn $ reqSession rr