git.iko.soy/typeable/req
on 990fcfe help sign in
9befc07
swap
0 ahead, 121 behind
.github/dependabot.ymldeleted−6
since splitsnapshots
unifiedsplit
@@ -1,6 +0,0 @@
1−version: 2
2−updates:
3− - package-ecosystem: "github-actions"
4− directory: "/"
5− schedule:
6− interval: "weekly"
.github/workflows/ci.yamldeleted−47
@@ -1,47 +0,0 @@
1−name: CI
2−on:
3− push:
4− branches:
5− - master
6− pull_request:
7− types:
8− - opened
9− - synchronize
10−jobs:
11− ormolu:
12− runs-on: ubuntu-latest
13− steps:
14− - uses: actions/checkout@v4
15− - uses: haskell-actions/run-ormolu@v17
16− build:
17− runs-on: ubuntu-latest
18− needs: ormolu
19− strategy:
20− matrix:
21− cabal: ["3.12"]
22− ghc: ["9.6.3", "9.8.2", "9.10.1"]
23− steps:
24− - uses: actions/checkout@v4
25− - uses: haskell-actions/setup@v2
26− id: setup-haskell-cabal
27− with:
28− ghc-version: ${{ matrix.ghc }}
29− cabal-version: ${{ matrix.cabal }}
30− - run: cabal update
31− - run: cabal freeze
32− - uses: actions/cache@v4.2.3
33− with:
34− path: |
35− ${{ steps.setup-haskell-cabal.outputs.cabal-store }}
36− dist-newstyle
37− key: ${{ runner.os }}-${{ matrix.ghc }}-${{ hashFiles('cabal.project.freeze') }}
38− restore-keys: |
39− ${{ runner.os }}-${{ matrix.ghc }}-
40− - run: cabal format && git diff --exit-code --color=always
41− - run: cabal build
42− - run: |
43− docker pull kennethreitz/httpbin
44− docker run -p 1234:80 kennethreitz/httpbin &
45− cabal test
46− - run: cabal haddock
47− - run: cabal sdist
.gitignore−1
@@ -25,6 +25,5 @@ cabal.project.local
25cabal.sandbox.config
25cabal.sandbox.config
26dist-*/
26dist-*/
27dist/
27dist/
28−hie.yaml
29stack.yaml
28stack.yaml
30stack.yaml.lock
29stack.yaml.lock
.travis.ymlnew file+39
@@ -0,0 +1,39 @@
1+language: c
2+
3+sudo: false
4+
5+cache:
6+ directories:
7+ - ~/.cabal/packages
8+ - ~/.cabal/store
9+
10+matrix:
11+ include:
12+ - env: CABALVER=3.0 GHCVER=8.6.5
13+ addons: {apt: {packages: [cabal-install-3.0,ghc-8.6.5], sources: [hvr-ghc]}}
14+ - env: CABALVER=3.0 GHCVER=8.8.3
15+ addons: {apt: {packages: [cabal-install-3.0,ghc-8.8.3], sources: [hvr-ghc]}}
16+ - env: CABALVER=3.0 GHCVER=8.10.1
17+ addons: {apt: {packages: [cabal-install-3.0,ghc-8.10.1], sources: [hvr-ghc]}}
18+
19+before_install:
20+ - export PATH=/opt/ghc/$GHCVER/bin:/opt/cabal/$CABALVER/bin:$PATH
21+
22+install:
23+ - cabal --version
24+ - ghc --version
25+ - travis_retry cabal new-update
26+
27+script:
28+ # To avoid re-compilation it is important to use exactly the same
29+ # configuration for all steps.
30+ - export CONFIG="--enable-tests --enable-benchmarks --flags=dev"
31+ - cabal format
32+ - git diff --exit-code --color=always
33+ - cabal new-build $CONFIG
34+ - cabal new-test $CONFIG
35+ - cabal new-haddock $CONFIG
36+ - cabal new-sdist
37+
38+notifications:
39+ email: false
CHANGELOG.md−105
@@ -1,108 +1,3 @@
1−## Req 3.13.4
2−
3−* Fixed empty ciphersuite list when compiling against `tls < 2.0.6`
4− (see [PR 175](https://github.com/mrkkrp/req/pull/175)). As a side effect, now
5− compatible with older versions of `crypton-connection` (>= 0.3).
6−
7−## Req 3.13.3
8−
9−* Works with `crypton-connection-0.4` and newer.
10−
11−## Req 3.13.2
12−
13−* Disable the problematic `httpbin-tests` test suite by default. Only enable
14− it when the `dev` flag is enabled. In that case it is expected that an
15− httpbin server is run locally at `localhost:1234`.
16−
17−## Req 3.13.1
18−
19−* Switched the non-pure test suite to use https://httpbun.org instead of
20− https://httpbin.org since the latter proved to be highly unreliable
21− lately.
22−
23−* Switched from `connection` to `crypton-connection`.
24−
25−* Builds with GHC 9.6.1.
26−
27−## Req 3.13.0
28−
29−* Add `headerRedacted` function to add header fields, which will be with
30− redacted values on print.
31−
32−## Req 3.12.0
33−
34−* Add `isStatusCodeException` function.
35−* Add `instance HttpResponse (Network.HTTP.Client.Response ())`.
36−
37−## Req 3.11.0
38−
39−* Add the `queryParamToList` method to the `QueryParam` type class.
40−* Add the `formToQuery` function. [Issue 126](https://github.com/mrkkrp/req/issues/126).
41−* Add `FromForm` instances (in the `Web.FormUrlEncoded` module) to the
42− `Option` and `FormUrlEncodedParam` types.
43−
44−## Req 3.10.0
45−
46−* Add `MonadHttp` instances for `transformers` types.
47−
48−## Req 3.9.2
49−
50−* The test suite works with `aeson-2.x.x.x`.
51−
52−## Req 3.9.1
53−
54−* Builds with GHC 9.0.
55−
56−## Req 3.9.0
57−
58−* The `useHttpURI` and `useHttpsURI` functions now preserve trailing
59− slashes.
60−
61−## Req 3.8.0
62−
63−* Adjusted the value of the `httpConfigRetryJudgeException` field of
64− `defaultHttpConfig` to retry on response timeouts and connection timeouts.
65−
66−## Req 3.7.0
67−
68−* Added `reqCb`, a function that allows you to modify the `Request` object
69− but otherwise performs the requst for you.
70−
71−* Derived `MonadThrow`, `MonadCatch`, and `MonadMask` for the `Req` monad.
72−
73−## Req 3.6.0
74−
75−* Added the `httpConfigBodyPreviewLength` configuration parameter to
76− `HttpConfig`.
77−
78−## Req 3.5.0
79−
80−* Made `Req` an instance of `MonadUnliftIO`. [Issue
81− 100](https://github.com/mrkkrp/req/issues/100).
82−
83−## Req 3.4.0
84−
85−* Requests using `DELETE` method can now have a body. [Issue
86− 89](https://github.com/mrkkrp/req/issues/89).
87−
88−* Added the `httpConfigRetryJudgeException` field to `HttpConfig` so that
89− requests that result in exceptions can be retried. [Issue
90− 93](https://github.com/mrkkrp/req/issues/93).
91−
92−* Added the function `renderUrl`. [Issue
93− 83](https://github.com/mrkkrp/req/issues/83).
94−
95−## Req 3.3.0
96−
97−* Derived `Show` instances for response types `IgnoreResponse`,
98− `JsonResponse`, `BsResponse`, and `LbsResponse`.
99−
100−## Req 3.2.0
101−
102−* Made the tests pass with `http-client-0.7` and later.
103−
104−* Added a quasiquoter for URL creation, `urlQ`.
105−
106## Req 3.1.0
1## Req 3.1.0
107
2
108* Changed signature of `httpConfigRetryPolicy` to `RetryPolicyM IO`.
3* Changed signature of `httpConfigRetryPolicy` to `RetryPolicyM IO`.
Network/HTTP/Req.hs+181−466
@@ -1,10 +1,17 @@
1+{-# LANGUAGE BangPatterns #-}
1{-# LANGUAGE DataKinds #-}
2{-# LANGUAGE DataKinds #-}
3+{-# LANGUAGE DeriveDataTypeable #-}
4+{-# LANGUAGE DeriveGeneric #-}
5+{-# LANGUAGE FlexibleInstances #-}
6+{-# LANGUAGE GeneralizedNewtypeDeriving #-}
7+{-# LANGUAGE KindSignatures #-}
2{-# LANGUAGE LambdaCase #-}
8{-# LANGUAGE LambdaCase #-}
9+{-# LANGUAGE MultiParamTypeClasses #-}
3{-# LANGUAGE OverloadedStrings #-}
10{-# LANGUAGE OverloadedStrings #-}
4{-# LANGUAGE QuasiQuotes #-}
11{-# LANGUAGE QuasiQuotes #-}
12+{-# LANGUAGE RankNTypes #-}
5{-# LANGUAGE RecordWildCards #-}
13{-# LANGUAGE RecordWildCards #-}
6−{-# LANGUAGE RoleAnnotations #-}
14+{-# LANGUAGE ScopedTypeVariables #-}
7−{-# LANGUAGE TemplateHaskellQuotes #-}
8{-# LANGUAGE TypeFamilies #-}
15{-# LANGUAGE TypeFamilies #-}
9{-# LANGUAGE UndecidableInstances #-}
16{-# LANGUAGE UndecidableInstances #-}
10
17
@@ -19,40 +26,61 @@
19--
26--
20-- The documentation below is structured in such a way that the most
27-- The documentation below is structured in such a way that the most
21-- important information is presented first: you learn how to do HTTP
28-- important information is presented first: you learn how to do HTTP
22−-- requests, how to embed them in the monad you have, and then it gives you
29+-- requests, how to embed them in any monad you have, and then it gives you
23-- details about less-common things you may want to know about. The
30-- details about less-common things you may want to know about. The
24-- documentation is written with sufficient coverage of details and
31-- documentation is written with sufficient coverage of details and
25-- examples, and it's designed to be a complete tutorial on its own.
32-- examples, and it's designed to be a complete tutorial on its own.
26--
33--
34+-- /(A modest intro goes here, click on 'req' to start making requests.)/
35+--
27-- === About the library
36-- === About the library
28--
37--
29−-- Req is an HTTP client library that attempts to be easy-to-use, type-safe,
38+-- Req is an easy-to-use, type-safe, expandable, high-level HTTP client
30−-- and expandable.
39+-- library that just works without any fooling around.
31−--
40+--
32−-- “Easy-to-use” means that the library is designed to be beginner-friendly
41+-- What does the phrase “easy-to-use” mean? It means that the library is
33−-- so it's simple to add to your monad stack, intuitive to work with,
42+-- designed to be beginner-friendly so it's simple to add to your monad
34−-- well-documented, and does not get in your way. Doing HTTP requests is a
43+-- stack, intuitive to work with, well-documented, and does not get in your
35−-- common task and a Haskell library for this should be approachable and
44+-- way. Doing HTTP requests is a common task and Haskell library for this
45+-- should be very approachable and clear to beginners, thus certain
36−-- clear to beginners, thus certain compromises were made. For example, one
46+-- compromises were made. For example, one cannot currently modify
37−-- cannot currently modify 'L.ManagerSettings' of the default manager
47+-- 'L.ManagerSettings' of the default manager because the library always
38−-- because the library always uses the same implicit global manager for
48+-- uses the same implicit global manager for simplicity and maximal
39−-- simplicity and maximal connection sharing. There is a way to use your own
49+-- connection sharing. There is a way to use your own manager with different
40−-- manager with different settings, but it requires more typing.
50+-- settings, but it requires a bit more typing.
41−--
51+--
42−-- “Type-safe” means that the library tries to eliminate certain classes of
52+-- “Type-safe” means that the library is protective and eliminates certain
43−-- errors. For example, we have correct-by-construction URLs; it is
53+-- classes of errors. For example, we have correct-by-construction 'Url's,
44−-- guaranteed that the user does not send the request body when using
54+-- it's guaranteed that the user does not send the request body when using
45−-- methods like GET or OPTIONS, and the amount of implicit assumptions is
55+-- methods like 'GET' or 'OPTIONS', and the amount of implicit assumptions
46−-- minimized by making the user specify their intentions in an explicit
56+-- is minimized by making the user specify his\/her intentions in an
47−-- form. For example, it's not possible to avoid specifying the body or the
57+-- explicit form (for example, it's not possible to avoid specifying the
48−-- method of a request. Authentication methods that assume HTTPS force the
58+-- body or method of request). Authentication methods that assume HTTPS
49−-- user to use HTTPS at the type level.
59+-- force the user to use HTTPS at the type level. The library also carefully
60+-- hides underlying types from the lower-level @http-client@ package because
61+-- those types are not safe enough (for example 'L.Request' is an instance
62+-- of 'Data.String.IsString' and, if it's malformed, it will blow up at
63+-- run-time).
50−--
64+--
51−-- “Expandable” refers to the ability to create new components without
65+-- “Expandable” refers to the ability of the library to be expanded without
52−-- having to resort to hacking. For example, it's possible to define your
66+-- having to resort to ugly hacking. For example, it's possible to define
53−-- own HTTP methods, create new ways to construct the body of a request,
67+-- your own HTTP methods, create new ways to construct the body of a
54−-- create new authorization options, perform a request in a different way,
68+-- request, create new authorization options, perform a request in a
55−-- and create your own methods to parse a response.
69+-- different way, and create your own methods to parse and represent a
70+-- response. As the user extends the library to satisfy his\/her special
71+-- needs, the new solutions will work just like the built-ins. However, all
72+-- of the common cases are also covered by the library out-of-the-box.
73+--
74+-- “High-level” means that there are less details to worry about. The
75+-- library is a result of my experiences as a Haskell consultant. Working
76+-- for several clients, who had very different projects, showed me that the
77+-- library should adapt easily to any particular style of writing Haskell
78+-- applications. For example, some people prefer throwing exceptions, while
79+-- others are concerned with purity. Just define 'handleHttpException'
80+-- accordingly when making your monad instance of 'MonadHttp' and it will
81+-- play together seamlessly. Finally, the library cuts down boilerplate
82+-- considerably, and helps you write concise, easy to read, and maintainable
83+-- code.
56--
84--
57-- === Using with other libraries
85-- === Using with other libraries
58--
86--
@@ -81,7 +109,6 @@ module Network.HTTP.Req
81 -- $making-a-request
109 -- $making-a-request
82 req,
110 req,
83 reqBr,
111 reqBr,
84− reqCb,
85 req',
112 req',
86 withReqManager,
113 withReqManager,
87
114
@@ -118,8 +145,6 @@ module Network.HTTP.Req
118 useHttpURI,
145 useHttpURI,
119 useHttpsURI,
146 useHttpsURI,
120 useURI,
147 useURI,
121− urlQ,
122− renderUrl,
123
148
124 -- ** Body
149 -- ** Body
125 -- $body
150 -- $body
@@ -144,13 +169,11 @@ module Network.HTTP.Req
144 -- $query-parameters
169 -- $query-parameters
145 (=:),
170 (=:),
146 queryFlag,
171 queryFlag,
147− formToQuery,
148 QueryParam (..),
172 QueryParam (..),
149
173
150 -- *** Headers
174 -- *** Headers
151 header,
175 header,
152 attachHeader,
176 attachHeader,
153− headerRedacted,
154
177
155 -- *** Cookies
178 -- *** Cookies
156 -- $cookies
179 -- $cookies
@@ -197,78 +220,52 @@ module Network.HTTP.Req
197
220
198 -- * Other
221 -- * Other
199 HttpException (..),
222 HttpException (..),
200− isStatusCodeException,
201 CanHaveBody (..),
223 CanHaveBody (..),
202 Scheme (..),
224 Scheme (..),
203 )
225 )
204where
226where
205
227
206−import Blaze.ByteString.Builder qualified as BB
228+import qualified Blaze.ByteString.Builder as BB
207import Control.Applicative
229import Control.Applicative
208import Control.Arrow (first, second)
230import Control.Arrow (first, second)
209−import Control.Exception hiding (Handler (..), TypeError)
231+import Control.Exception hiding (TypeError)
210−import Control.Monad (guard, void, (>=>))
211import Control.Monad.Base
232import Control.Monad.Base
212−import Control.Monad.Catch (Handler (..), MonadCatch, MonadMask, MonadThrow)
213import Control.Monad.IO.Class
233import Control.Monad.IO.Class
214−import Control.Monad.IO.Unlift
234+import Control.Monad.Reader
215−import Control.Monad.Reader (ReaderT (ReaderT), ask, lift, runReaderT)
216−import Control.Monad.Trans.Accum (AccumT)
217−import Control.Monad.Trans.Cont (ContT)
218import Control.Monad.Trans.Control
235import Control.Monad.Trans.Control
219−import Control.Monad.Trans.Except (ExceptT)
220−import Control.Monad.Trans.Identity (IdentityT)
221−import Control.Monad.Trans.Maybe (MaybeT)
222−import Control.Monad.Trans.RWS.CPS qualified as RWS.CPS
223−import Control.Monad.Trans.RWS.Lazy qualified as RWS.Lazy
224−import Control.Monad.Trans.RWS.Strict qualified as RWS.Strict
225−import Control.Monad.Trans.Select (SelectT)
226−import Control.Monad.Trans.State.Lazy qualified as State.Lazy
227−import Control.Monad.Trans.State.Strict qualified as State.Strict
228−import Control.Monad.Trans.Writer.CPS qualified as Writer.CPS
229−import Control.Monad.Trans.Writer.Lazy qualified as Writer.Lazy
230−import Control.Monad.Trans.Writer.Strict qualified as Writer.Strict
231import Control.Retry
236import Control.Retry
232import Data.Aeson (FromJSON (..), ToJSON (..))
237import Data.Aeson (FromJSON (..), ToJSON (..))
233−import Data.Aeson qualified as A
238+import qualified Data.Aeson as A
234import Data.ByteString (ByteString)
239import Data.ByteString (ByteString)
235−import Data.ByteString qualified as B
240+import qualified Data.ByteString as B
236−import Data.ByteString.Lazy qualified as BL
241+import qualified Data.ByteString.Lazy as BL
237−import Data.CaseInsensitive qualified as CI
242+import qualified Data.CaseInsensitive as CI
238import Data.Data (Data)
243import Data.Data (Data)
239−import Data.Default.Class (def)
240import Data.Function (on)
244import Data.Function (on)
241import Data.IORef
245import Data.IORef
242import Data.Kind (Constraint, Type)
246import Data.Kind (Constraint, Type)
243import Data.List (foldl', nubBy)
247import Data.List (foldl', nubBy)
244import Data.List.NonEmpty (NonEmpty (..))
248import Data.List.NonEmpty (NonEmpty (..))
245−import Data.List.NonEmpty qualified as NE
249+import qualified Data.List.NonEmpty as NE
246import Data.Maybe (fromMaybe)
250import Data.Maybe (fromMaybe)
247import Data.Proxy
251import Data.Proxy
248−import Data.Semigroup (Endo (..))
252+import Data.Semigroup hiding (Option, option)
249−import Data.Set qualified as S
250import Data.Text (Text)
253import Data.Text (Text)
251−import Data.Text qualified as T
252−import Data.Text.Encoding qualified as T
254+import qualified Data.Text.Encoding as T
253−import Data.Typeable (Typeable, cast)
255+import Data.Typeable (Typeable)
254import GHC.Generics
256import GHC.Generics
255import GHC.TypeLits
257import GHC.TypeLits
256−import Language.Haskell.TH qualified as TH
257−import Language.Haskell.TH.Quote qualified as TH
258−import Language.Haskell.TH.Syntax qualified as TH
259−import Network.Connection qualified as NC
258+import qualified Network.Connection as NC
260−import Network.HTTP.Client qualified as L
259+import qualified Network.HTTP.Client as L
261−import Network.HTTP.Client.Internal qualified as LI
260+import qualified Network.HTTP.Client.Internal as LI
262−import Network.HTTP.Client.MultipartFormData qualified as LM
261+import qualified Network.HTTP.Client.MultipartFormData as LM
263−import Network.HTTP.Client.TLS qualified as L
262+import qualified Network.HTTP.Client.TLS as L
264−import Network.HTTP.Types qualified as Y
263+import qualified Network.HTTP.Types as Y
265import System.IO.Unsafe (unsafePerformIO)
264import System.IO.Unsafe (unsafePerformIO)
266import Text.URI (URI)
265import Text.URI (URI)
267−import Text.URI qualified as URI
266+import qualified Text.URI as URI
268−import Text.URI.QQ qualified as QQ
267+import qualified Text.URI.QQ as QQ
269−import Web.Authenticate.OAuth qualified as OAuth
268+import qualified Web.Authenticate.OAuth as OAuth
270−import Web.FormUrlEncoded (FromForm (..), ToForm (..))
271−import Web.FormUrlEncoded qualified as Form
272import Web.HttpApiData (ToHttpApiData (..))
269import Web.HttpApiData (ToHttpApiData (..))
273
270
274----------------------------------------------------------------------------
271----------------------------------------------------------------------------
@@ -293,7 +290,7 @@ import Web.HttpApiData (ToHttpApiData (..))
293--
290--
294-- @body@ is a body option such as 'NoReqBody' or 'ReqBodyJson'. The
291-- @body@ is a body option such as 'NoReqBody' or 'ReqBodyJson'. The
295-- tutorial has a section about HTTP bodies, but usage is very
292-- tutorial has a section about HTTP bodies, but usage is very
296−-- straightforward and should be clear from the examples.
293+-- straightforward and should be clear from the examples below.
297--
294--
298-- @response@ is a type hint how to make and interpret response of an HTTP
295-- @response@ is a type hint how to make and interpret response of an HTTP
299-- request. Out-of-the-box it can be the following:
296-- request. Out-of-the-box it can be the following:
@@ -421,7 +418,12 @@ req ::
421 -- | Response
418 -- | Response
422 m response
419 m response
423req method url body responseProxy options =
420req method url body responseProxy options =
424− reqCb method url body responseProxy options pure
421+ reqBr method url body (options <> extraOptions) getHttpResponse
422+ where
423+ extraOptions =
424+ case acceptHeader responseProxy of
425+ Nothing -> mempty
426+ Just accept -> header "Accept" accept
425
427
426-- | A version of 'req' that does not use one of the predefined instances of
428-- | A version of 'req' that does not use one of the predefined instances of
427-- 'HttpResponse' but instead allows the user to consume @'L.Response'
429-- 'HttpResponse' but instead allows the user to consume @'L.Response'
@@ -446,58 +448,7 @@ reqBr ::
446 (L.Response L.BodyReader -> IO a) ->
448 (L.Response L.BodyReader -> IO a) ->
447 -- | Result
449 -- | Result
448 m a
450 m a
449−reqBr method url body options consume =
451+reqBr method url body options consume = req' method url body options $ \request manager -> do
450− req' method url body options (reqHandler consume)
451−
452−-- | A version of 'req' that takes a callback to modify the 'L.Request', but
453−-- otherwise performs the request identically.
454−--
455−-- @since 3.7.0
456−reqCb ::
457− ( MonadHttp m,
458− HttpMethod method,
459− HttpBody body,
460− HttpResponse response,
461− HttpBodyAllowed (AllowsBody method) (ProvidesBody body)
462− ) =>
463− -- | HTTP method
464− method ->
465− -- | 'Url'—location of resource
466− Url scheme ->
467− -- | Body of the request
468− body ->
469− -- | A hint how to interpret response
470− Proxy response ->
471− -- | Collection of optional parameters
472− Option scheme ->
473− -- | Callback to modify the request
474− (L.Request -> m L.Request) ->
475− -- | Response
476− m response
477−reqCb method url body responseProxy options adjustRequest =
478− req' method url body (options <> extraOptions) $ \request manager -> do
479− request' <- adjustRequest request
480− reqHandler getHttpResponse request' manager
481− where
482− extraOptions =
483− case acceptHeader responseProxy of
484− Nothing -> mempty
485− Just accept -> header "Accept" accept
486−
487−-- | The default handler function that the higher-level request functions
488−-- pass to 'req''. Internal function.
489−--
490−-- @since 3.7.0
491−reqHandler ::
492− (MonadHttp m) =>
493− -- | How to get final result from a 'L.Response'
494− (L.Response L.BodyReader -> IO b) ->
495− -- | 'L.Request' to perform
496− L.Request ->
497− -- | 'L.Manager' to use
498− L.Manager ->
499− m b
500−reqHandler consume request manager = do
501 HttpConfig {..} <- getHttpConfig
452 HttpConfig {..} <- getHttpConfig
502 let wrapVanilla = handle (throwIO . VanillaHttpException)
453 let wrapVanilla = handle (throwIO . VanillaHttpException)
503 wrapExc = handle (throwIO . LI.toHttpException request)
454 wrapExc = handle (throwIO . LI.toHttpException request)
@@ -513,23 +464,12 @@ reqHandler consume request manager = do
513 r' <- L.responseOpen request manager
464 r' <- L.responseOpen request manager
514 writeIORef rref (Just r')
465 writeIORef rref (Just r')
515 return r'
466 return r'
516− exceptionRetryPolicies =
517− skipAsyncExceptions
518− ++ [ \retryStatus -> Handler $ \e ->
519− return $ httpConfigRetryJudgeException retryStatus e
520− ]
521 r <-
467 r <-
522 retrying
468 retrying
523 httpConfigRetryPolicy
469 httpConfigRetryPolicy
524− (\retryStatus r -> return $ httpConfigRetryJudge retryStatus r)
470+ (\st r -> return $ httpConfigRetryJudge st r)
525− ( const
526− ( recovering
527− httpConfigRetryPolicy
528− exceptionRetryPolicies
529− (const openResponse)
471+ (const openResponse)
530− )
531− )
532− (preview, r') <- grabPreview httpConfigBodyPreviewLength r
472+ (preview, r') <- grabPreview bodyPreviewLength r
533 mapM_ LI.throwHttp (httpConfigCheckResponse request r' preview)
473 mapM_ LI.throwHttp (httpConfigCheckResponse request r' preview)
534 consume r'
474 consume r'
535 )
475 )
@@ -578,22 +518,22 @@ req' method url body options m = do
578 nubHeaders
518 nubHeaders
579 <> getRequestMod options
519 <> getRequestMod options
580 <> getRequestMod config
520 <> getRequestMod config
581− <> getRequestMod (Tagged body :: Tagged "body" body)
521+ <> getRequestMod (Womb body :: Womb "body" body)
582 <> getRequestMod url
522 <> getRequestMod url
583− <> getRequestMod (Tagged method :: Tagged "method" method)
523+ <> getRequestMod (Womb method :: Womb "method" method)
584 request <- finalizeRequest options request'
524 request <- finalizeRequest options request'
585 withReqManager (m request)
525 withReqManager (m request)
586
526
587-- | Perform an action using the global implicit 'L.Manager' that the rest
527-- | Perform an action using the global implicit 'L.Manager' that the rest
588−-- of the library uses. This allows us to reuse connections that the
528+-- of the library uses. This allows to reuse connections that the
589-- 'L.Manager' controls.
529-- 'L.Manager' controls.
590−withReqManager :: (MonadIO m) => (L.Manager -> m a) -> m a
530+withReqManager :: MonadIO m => (L.Manager -> m a) -> m a
591−withReqManager m = m globalManager
531+withReqManager m = liftIO (readIORef globalManager) >>= m
592
532
593−-- | The global 'L.Manager' that 'req' uses. Here we just go with the
533+-- | Global 'L.Manager' that 'req' uses. Here we just go with the default
594−-- default settings, so users don't need to deal with this manager stuff at
534+-- settings, so users don't need to deal with this manager stuff at all, but
595−-- all, but when we create a request, instance 'HttpConfig' can affect the
535+-- when we create a request, instance 'HttpConfig' can affect the default
596−-- default settings via 'getHttpConfig'.
536+-- settings via 'getHttpConfig'.
597--
537--
598-- A note about safety, in case 'unsafePerformIO' looks suspicious to you.
538-- A note about safety, in case 'unsafePerformIO' looks suspicious to you.
599-- The value of 'globalManager' is named and lives on top level. This means
539-- The value of 'globalManager' is named and lives on top level. This means
@@ -601,16 +541,16 @@ withReqManager m = m globalManager
601-- manager. From that moment on the 'IORef' will be just reused—exactly the
541-- manager. From that moment on the 'IORef' will be just reused—exactly the
602-- behavior we want here in order to maximize connection sharing. GHC could
542-- behavior we want here in order to maximize connection sharing. GHC could
603-- spoil the plan by inlining the definition, hence the @NOINLINE@ pragma.
543-- spoil the plan by inlining the definition, hence the @NOINLINE@ pragma.
604−globalManager :: L.Manager
544+globalManager :: IORef L.Manager
605globalManager = unsafePerformIO $ do
545globalManager = unsafePerformIO $ do
606 context <- NC.initConnectionContext
546 context <- NC.initConnectionContext
607 let settings =
547 let settings =
608 L.mkManagerSettingsContext
548 L.mkManagerSettingsContext
609 (Just context)
549 (Just context)
610− def
550+ (NC.TLSSettingsSimple False False False)
611 Nothing
551 Nothing
612 manager <- L.newManager settings
552 manager <- L.newManager settings
613− return manager
553+ newIORef manager
614{-# NOINLINE globalManager #-}
554{-# NOINLINE globalManager #-}
615
555
616----------------------------------------------------------------------------
556----------------------------------------------------------------------------
@@ -624,13 +564,13 @@ globalManager = unsafePerformIO $ do
624-- When writing a library, keep your API polymorphic in terms of
564-- When writing a library, keep your API polymorphic in terms of
625-- 'MonadHttp', only define instance of 'MonadHttp' in final application.
565-- 'MonadHttp', only define instance of 'MonadHttp' in final application.
626-- Another option is to use a @newtype@-wrapped monad stack and define
566-- Another option is to use a @newtype@-wrapped monad stack and define
627−-- 'MonadHttp' for it. As of the version /0.4.0/, the 'Req' monad that
567+-- 'MonadHttp' for it. As of version /0.4.0/, the 'Req' monad that follows
628−-- follows this strategy is provided out-of-the-box (see below).
568+-- this strategy is provided out-of-the-box (see below).
629
569
630-- | A type class for monads that support performing HTTP requests.
570-- | A type class for monads that support performing HTTP requests.
631-- Typically, you only need to define the 'handleHttpException' method
571-- Typically, you only need to define the 'handleHttpException' method
632-- unless you want to tweak 'HttpConfig'.
572-- unless you want to tweak 'HttpConfig'.
633−class (MonadIO m) => MonadHttp m where
573+class MonadIO m => MonadHttp m where
634 -- | This method describes how to deal with 'HttpException' that was
574 -- | This method describes how to deal with 'HttpException' that was
635 -- caught by the library. One option is to re-throw it if you are OK with
575 -- caught by the library. One option is to re-throw it if you are OK with
636 -- exceptions, but if you prefer working with something like
576 -- exceptions, but if you prefer working with something like
@@ -638,16 +578,17 @@ class (MonadIO m) => MonadHttp m where
638 -- 'Control.Monad.Except.throwError'.
578 -- 'Control.Monad.Except.throwError'.
639 handleHttpException :: HttpException -> m a
579 handleHttpException :: HttpException -> m a
640
580
641− -- | Return the 'HttpConfig' to be used when performing HTTP requests.
581+ -- | Return 'HttpConfig' to be used when performing HTTP requests. Default
642− -- Default implementation returns its 'def' value, which is described in
582+ -- implementation returns its 'def' value, which is described in the
643− -- the documentation for the type. Common usage pattern with manually
583+ -- documentation for the type. Common usage pattern with manually defined
644− -- defined 'getHttpConfig' is to return some hard-coded value, or a value
584+ -- 'getHttpConfig' is to return some hard-coded value, or a value
645 -- extracted from 'Control.Monad.Reader.MonadReader' if a more flexible
585 -- extracted from 'Control.Monad.Reader.MonadReader' if a more flexible
646 -- approach to configuration is desirable.
586 -- approach to configuration is desirable.
647 getHttpConfig :: m HttpConfig
587 getHttpConfig :: m HttpConfig
648 getHttpConfig = return defaultHttpConfig
588 getHttpConfig = return defaultHttpConfig
649
589
650−-- | 'HttpConfig' contains settings to be used when making HTTP requests.
590+-- | 'HttpConfig' contains general and default settings to be used when
591+-- making HTTP requests.
651data HttpConfig = HttpConfig
592data HttpConfig = HttpConfig
652 { -- | Proxy to use. By default values of @HTTP_PROXY@ and @HTTPS_PROXY@
593 { -- | Proxy to use. By default values of @HTTP_PROXY@ and @HTTPS_PROXY@
653 -- environment variables are respected, this setting overwrites them.
594 -- environment variables are respected, this setting overwrites them.
@@ -691,8 +632,8 @@ data HttpConfig = HttpConfig
691 -- | The retry policy to use for request retrying. By default 'def' is
632 -- | The retry policy to use for request retrying. By default 'def' is
692 -- used (see 'RetryPolicyM').
633 -- used (see 'RetryPolicyM').
693 --
634 --
694− -- __Note__: signature of this function was changed to disallow 'IO' in
635+ -- __Note__: signature of this function was changed in the version
695− -- version /1.0.0/ and then changed back to its current form in /3.1.0/.
636+ -- /1.0.0/.
696 --
637 --
697 -- @since 0.3.0
638 -- @since 0.3.0
698 httpConfigRetryPolicy :: RetryPolicyM IO,
639 httpConfigRetryPolicy :: RetryPolicyM IO,
@@ -703,21 +644,11 @@ data HttpConfig = HttpConfig
703 -- /1.0.0/.
644 -- /1.0.0/.
704 --
645 --
705 -- @since 0.3.0
646 -- @since 0.3.0
706− httpConfigRetryJudge :: forall b. RetryStatus -> L.Response b -> Bool,
647+ httpConfigRetryJudge :: forall b. RetryStatus -> L.Response b -> Bool
707− -- | Similar to 'httpConfigRetryJudge', but is used to decide when to
708− -- retry requests that resulted in an exception. By default it retries
709− -- on response timeout and connection timeout (changed in version
710− -- /3.8.0/).
711− --
712− -- @since 3.4.0
713− httpConfigRetryJudgeException :: RetryStatus -> SomeException -> Bool,
714− -- | Max length of preview fragment of response body.
715− --
716− -- @since 3.6.0
717− httpConfigBodyPreviewLength :: forall a. (Num a) => a
718 }
648 }
649+ deriving (Typeable)
719
650
720−-- | The default value of 'HttpConfig'.
651+-- | Default value of 'HttpConfig'.
721--
652--
722-- @since 2.0.0
653-- @since 2.0.0
723defaultHttpConfig :: HttpConfig
654defaultHttpConfig :: HttpConfig
@@ -739,16 +670,7 @@ defaultHttpConfig =
739 524, -- A timeout occurred
670 524, -- A timeout occurred
740 598, -- (Informal convention) Network read timeout error
671 598, -- (Informal convention) Network read timeout error
741 599 -- (Informal convention) Network connect timeout error
672 599 -- (Informal convention) Network connect timeout error
742− ],
673+ ]
743− httpConfigRetryJudgeException = \_ e ->
744− case fromException e of
745− Just (L.HttpExceptionRequest _ c) ->
746− case c of
747− L.ResponseTimeout -> True
748− L.ConnectionTimeout -> True
749− _ -> False
750− _ -> False,
751− httpConfigBodyPreviewLength = 1024
752 }
674 }
753 where
675 where
754 statusCode = Y.statusCode . L.responseStatus
676 statusCode = Y.statusCode . L.responseStatus
@@ -761,7 +683,7 @@ instance RequestComponent HttpConfig where
761 LI.requestManagerOverride = httpConfigAltManager
683 LI.requestManagerOverride = httpConfigAltManager
762 }
684 }
763
685
764−-- | A monad that allows us to run 'req' in any 'IO'-enabled monad without
686+-- | A monad that allows to run 'req' in any 'IO'-enabled monad without
765-- having to define new instances.
687-- having to define new instances.
766--
688--
767-- @since 0.4.0
689-- @since 0.4.0
@@ -770,19 +692,9 @@ newtype Req a = Req (ReaderT HttpConfig IO a)
770 ( Functor,
692 ( Functor,
771 Applicative,
693 Applicative,
772 Monad,
694 Monad,
773− MonadIO,
695+ MonadIO
774− MonadUnliftIO
775 )
696 )
776
697
777−-- | @since 3.7.0
778−deriving instance MonadThrow Req
779−
780−-- | @since 3.7.0
781−deriving instance MonadCatch Req
782−
783−-- | @since 3.7.0
784−deriving instance MonadMask Req
785−
786instance MonadBase IO Req where
698instance MonadBase IO Req where
787 liftBase = liftIO
699 liftBase = liftIO
788
700
@@ -797,87 +709,12 @@ instance MonadHttp Req where
797 handleHttpException = Req . lift . throwIO
709 handleHttpException = Req . lift . throwIO
798 getHttpConfig = Req ask
710 getHttpConfig = Req ask
799
711
800−-- | @since 3.10.0
801−instance (MonadHttp m, Monoid w) => MonadHttp (AccumT w m) where
802− handleHttpException = lift . handleHttpException
803− getHttpConfig = lift getHttpConfig
804−
805−-- | @since 3.10.0
806−instance (MonadHttp m) => MonadHttp (ContT r m) where
807− handleHttpException = lift . handleHttpException
808− getHttpConfig = lift getHttpConfig
809−
810−-- | @since 3.10.0
811−instance (MonadHttp m) => MonadHttp (ExceptT e m) where
812− handleHttpException = lift . handleHttpException
813− getHttpConfig = lift getHttpConfig
814−
815−-- | @since 3.10.0
816−instance (MonadHttp m) => MonadHttp (IdentityT m) where
817− handleHttpException = lift . handleHttpException
818− getHttpConfig = lift getHttpConfig
819−
820−-- | @since 3.10.0
821−instance (MonadHttp m) => MonadHttp (MaybeT m) where
822− handleHttpException = lift . handleHttpException
823− getHttpConfig = lift getHttpConfig
824−
825−-- | @since 3.10.0
826−instance (MonadHttp m) => MonadHttp (ReaderT r m) where
827− handleHttpException = lift . handleHttpException
828− getHttpConfig = lift getHttpConfig
829−
830−-- | @since 3.10.0
831−instance (MonadHttp m, Monoid w) => MonadHttp (RWS.CPS.RWST r w s m) where
832− handleHttpException = lift . handleHttpException
833− getHttpConfig = lift getHttpConfig
834−
835−-- | @since 3.10.0
836−instance (MonadHttp m, Monoid w) => MonadHttp (RWS.Lazy.RWST r w s m) where
837− handleHttpException = lift . handleHttpException
838− getHttpConfig = lift getHttpConfig
839−
840−-- | @since 3.10.0
841−instance (MonadHttp m, Monoid w) => MonadHttp (RWS.Strict.RWST r w s m) where
842− handleHttpException = lift . handleHttpException
843− getHttpConfig = lift getHttpConfig
844−
845−-- | @since 3.10.0
846−instance (MonadHttp m) => MonadHttp (SelectT r m) where
847− handleHttpException = lift . handleHttpException
848− getHttpConfig = lift getHttpConfig
849−
850−-- | @since 3.10.0
851−instance (MonadHttp m) => MonadHttp (State.Lazy.StateT s m) where
852− handleHttpException = lift . handleHttpException
853− getHttpConfig = lift getHttpConfig
854−
855−-- | @since 3.10.0
856−instance (MonadHttp m) => MonadHttp (State.Strict.StateT s m) where
857− handleHttpException = lift . handleHttpException
858− getHttpConfig = lift getHttpConfig
859−
860−-- | @since 3.10.0
861−instance (MonadHttp m, Monoid w) => MonadHttp (Writer.CPS.WriterT w m) where
862− handleHttpException = lift . handleHttpException
863− getHttpConfig = lift getHttpConfig
864−
865−-- | @since 3.10.0
866−instance (MonadHttp m, Monoid w) => MonadHttp (Writer.Lazy.WriterT w m) where
867− handleHttpException = lift . handleHttpException
868− getHttpConfig = lift getHttpConfig
869−
870−-- | @since 3.10.0
871−instance (MonadHttp m, Monoid w) => MonadHttp (Writer.Strict.WriterT w m) where
872− handleHttpException = lift . handleHttpException
873− getHttpConfig = lift getHttpConfig
874−
875-- | Run a computation in the 'Req' monad with the given 'HttpConfig'. In
712-- | Run a computation in the 'Req' monad with the given 'HttpConfig'. In
876−-- the case of an exceptional situation an 'HttpException' will be thrown.
713+-- case of exceptional situation an 'HttpException' will be thrown.
877--
714--
878-- @since 0.4.0
715-- @since 0.4.0
879runReq ::
716runReq ::
880− (MonadIO m) =>
717+ MonadIO m =>
881 -- | 'HttpConfig' to use
718 -- | 'HttpConfig' to use
882 HttpConfig ->
719 HttpConfig ->
883 -- | Computation to run
720 -- | Computation to run
@@ -925,15 +762,14 @@ instance HttpMethod PUT where
925 type AllowsBody PUT = 'CanHaveBody
762 type AllowsBody PUT = 'CanHaveBody
926 httpMethodName Proxy = Y.methodPut
763 httpMethodName Proxy = Y.methodPut
927
764
928−-- | 'DELETE' method. RFC 7231 allows a payload in DELETE but without
765+-- | 'DELETE' method. This data type does not allow having request body with
929−-- semantics.
766+-- 'DELETE' requests, as it should be. However some APIs may expect 'DELETE'
930−--
767+-- requests to have bodies, in that case define your own variation of
931−-- __Note__: before version /3.4.0/ this method did not allow request
768+-- 'DELETE' method and allow it to have a body.
932−-- bodies.
933data DELETE = DELETE
769data DELETE = DELETE
934
770
935instance HttpMethod DELETE where
771instance HttpMethod DELETE where
936− type AllowsBody DELETE = 'CanHaveBody
772+ type AllowsBody DELETE = 'NoBody
937 httpMethodName Proxy = Y.methodDelete
773 httpMethodName Proxy = Y.methodDelete
938
774
939-- | 'TRACE' method.
775-- | 'TRACE' method.
@@ -982,7 +818,7 @@ class HttpMethod a where
982 -- | Return name of the method as a 'ByteString'.
818 -- | Return name of the method as a 'ByteString'.
983 httpMethodName :: Proxy a -> ByteString
819 httpMethodName :: Proxy a -> ByteString
984
820
985−instance (HttpMethod method) => RequestComponent (Tagged "method" method) where
821+instance HttpMethod method => RequestComponent (Womb "method" method) where
986 getRequestMod _ = Endo $ \x ->
822 getRequestMod _ = Endo $ \x ->
987 x {L.method = httpMethodName (Proxy :: Proxy method)}
823 x {L.method = httpMethodName (Proxy :: Proxy method)}
988
824
@@ -1024,20 +860,7 @@ instance (HttpMethod method) => RequestComponent (Tagged "method" method) where
1024-- > -- https://%D1%8E%D0%BD%D0%B8%D0%BA%D0%BE%D0%B4.%D1%80%D1%84
860-- > -- https://%D1%8E%D0%BD%D0%B8%D0%BA%D0%BE%D0%B4.%D1%80%D1%84
1025data Url (scheme :: Scheme) = Url Scheme (NonEmpty Text)
861data Url (scheme :: Scheme) = Url Scheme (NonEmpty Text)
1026 -- NOTE The second value is the path segments in reversed order.
862 -- NOTE The second value is the path segments in reversed order.
1027− deriving (Eq, Ord, Show, Data, Generic)
863+ deriving (Eq, Ord, Show, Data, Typeable, Generic)
1028−
1029−type role Url nominal
1030−
1031−-- With template-haskell >=2.15 and text >=1.2.4 Lift can be derived, however
1032−-- the derived lift forgets the type of the scheme.
1033−instance (Typeable scheme) => TH.Lift (Url scheme) where
1034− lift url =
1035− TH.dataToExpQ (fmap liftText . cast) url `TH.sigE` case url of
1036− Url Http _ -> [t|Url 'Http|]
1037− Url Https _ -> [t|Url 'Https|]
1038− where
1039− liftText t = TH.AppE (TH.VarE 'T.pack) <$> TH.lift (T.unpack t)
1040− liftTyped = TH.Code . TH.unsafeTExpCoerce . TH.lift
1041
864
1042-- | Given host name, produce a 'Url' which has “http” as its scheme and
865-- | Given host name, produce a 'Url' which has “http” as its scheme and
1043-- empty path. This also sets port to @80@.
866-- empty path. This also sets port to @80@.
@@ -1049,33 +872,20 @@ http = Url Http . pure
1049https :: Text -> Url 'Https
872https :: Text -> Url 'Https
1050https = Url Https . pure
873https = Url Https . pure
1051
874
1052−-- | Grow a given 'Url' appending a single path segment to it. Note that the
875+-- | Grow given 'Url' appending a single path segment to it. Note that the
1053-- path segment can be of any type that is an instance of 'ToHttpApiData'.
876-- path segment can be of any type that is an instance of 'ToHttpApiData'.
1054infixl 5 /~
877infixl 5 /~
1055
878
1056−(/~) :: (ToHttpApiData a) => Url scheme -> a -> Url scheme
879+(/~) :: ToHttpApiData a => Url scheme -> a -> Url scheme
1057Url secure path /~ segment = Url secure (NE.cons (toUrlPiece segment) path)
880Url secure path /~ segment = Url secure (NE.cons (toUrlPiece segment) path)
1058
881
1059−-- | A type-constrained version of @('/~')@ to remove ambiguity in the cases
882+-- | Type-constrained version of @('/~')@ to remove ambiguity in the cases
1060-- when next URL piece is a 'Data.Text.Text' literal.
883-- when next URL piece is a 'Data.Text.Text' literal.
1061infixl 5 /:
884infixl 5 /:
1062
885
1063(/:) :: Url scheme -> Text -> Url scheme
886(/:) :: Url scheme -> Text -> Url scheme
1064(/:) = (/~)
887(/:) = (/~)
1065
888
1066−-- | Render a 'Url' as 'Text'.
1067−--
1068−-- @since 3.4.0
1069−renderUrl :: Url scheme -> Text
1070−renderUrl = \case
1071− Url Https parts ->
1072− "https://" <> renderParts parts
1073− Url Http parts ->
1074− "http://" <> renderParts parts
1075− where
1076− renderParts parts =
1077− T.intercalate "/" (reverse $ NE.toList parts)
1078−
1079-- | The 'useHttpURI' function provides an alternative method to get 'Url'
889-- | The 'useHttpURI' function provides an alternative method to get 'Url'
1080-- (possibly with some 'Option's) from a 'URI'. This is useful when you are
890-- (possibly with some 'Option's) from a 'URI'. This is useful when you are
1081-- given a URL to query dynamically and don't know it beforehand.
891-- given a URL to query dynamically and don't know it beforehand.
@@ -1089,7 +899,8 @@ useHttpURI uri = do
1089 urlHead <- http <$> uriHost uri
899 urlHead <- http <$> uriHost uri
1090 let url = case URI.uriPath uri of
900 let url = case URI.uriPath uri of
1091 Nothing -> urlHead
901 Nothing -> urlHead
1092− Just uriPath -> uriPathToUrl uriPath urlHead
902+ Just (_, xs) ->
903+ foldl' (/:) urlHead (URI.unRText <$> NE.toList xs)
1093 return (url, uriOptions uri)
904 return (url, uriOptions uri)
1094
905
1095-- | Just like 'useHttpURI', but expects the “https” scheme.
906-- | Just like 'useHttpURI', but expects the “https” scheme.
@@ -1101,21 +912,10 @@ useHttpsURI uri = do
1101 urlHead <- https <$> uriHost uri
912 urlHead <- https <$> uriHost uri
1102 let url = case URI.uriPath uri of
913 let url = case URI.uriPath uri of
1103 Nothing -> urlHead
914 Nothing -> urlHead
1104− Just uriPath -> uriPathToUrl uriPath urlHead
915+ Just (_, xs) ->
916+ foldl' (/:) urlHead (URI.unRText <$> NE.toList xs)
1105 return (url, uriOptions uri)
917 return (url, uriOptions uri)
1106
918
1107−-- | Convert URI path to a 'Url'. Internal.
1108−--
1109−-- @since 3.9.0
1110−uriPathToUrl ::
1111− (Bool, NonEmpty (URI.RText 'URI.PathPiece)) ->
1112− Url scheme ->
1113− Url scheme
1114−uriPathToUrl (trailingSlash, xs) urlHead =
1115− if trailingSlash then path /: T.empty else path
1116− where
1117− path = foldl' (/:) urlHead (URI.unRText <$> NE.toList xs)
1118−
1119-- | A combination of 'useHttpURI' and 'useHttpsURI' for cases when scheme
919-- | A combination of 'useHttpURI' and 'useHttpsURI' for cases when scheme
1120-- is not known in advance.
920-- is not known in advance.
1121--
921--
@@ -1137,29 +937,6 @@ uriHost uri = case URI.uriAuthority uri of
1137 Right URI.Authority {..} ->
937 Right URI.Authority {..} ->
1138 Just (URI.unRText authHost)
938 Just (URI.unRText authHost)
1139
939
1140−-- | A quasiquoter to build an 'Url' and 'Option' tuple. The type of the
1141−-- generated expression is @('Url' scheme0, 'Option' scheme1)@ with
1142−-- @scheme0@ being either 'Http' or 'Https' depending on the input.
1143−--
1144−-- @since 3.2.0
1145−urlQ :: TH.QuasiQuoter
1146−urlQ =
1147− TH.QuasiQuoter
1148− { quoteExp = \str ->
1149− case URI.mkURI (T.pack str) of
1150− Left err -> fail (displayException err)
1151− Right uri -> case useURI uri of
1152− Nothing -> fail "Not a HTTP or HTTPS URL"
1153− Just eurl ->
1154− TH.tupE
1155− [ either (TH.lift . fst) (TH.lift . fst) eurl,
1156− [|uriOptions uri|]
1157− ],
1158− quotePat = error "This usage is not supported",
1159− quoteType = error "This usage is not supported",
1160− quoteDec = error "This usage is not supported"
1161− }
1162−
1163-- | An internal helper function to extract 'Option's from a 'URI'.
940-- | An internal helper function to extract 'Option's from a 'URI'.
1164uriOptions :: forall scheme. URI -> Option scheme
941uriOptions :: forall scheme. URI -> Option scheme
1165uriOptions uri =
942uriOptions uri =
@@ -1232,21 +1009,21 @@ data NoReqBody = NoReqBody
1232instance HttpBody NoReqBody where
1009instance HttpBody NoReqBody where
1233 getRequestBody NoReqBody = L.RequestBodyBS B.empty
1010 getRequestBody NoReqBody = L.RequestBodyBS B.empty
1234
1011
1235−-- | This body option allows us to use a JSON object as the request
1012+-- | This body option allows to use a JSON object as request body—probably
1236−-- body—probably the most popular format right now. Just wrap a data type
1013+-- the most popular format right now. Just wrap a data type that is an
1237−-- that is an instance of 'ToJSON' type class and you are done: it will be
1014+-- instance of 'ToJSON' type class and you are done: it will be converted to
1238−-- converted to JSON and inserted as request body.
1015+-- JSON and inserted as request body.
1239--
1016--
1240-- This body option sets the @Content-Type@ header to @\"application/json;
1017-- This body option sets the @Content-Type@ header to @\"application/json;
1241-- charset=utf-8\"@ value.
1018-- charset=utf-8\"@ value.
1242newtype ReqBodyJson a = ReqBodyJson a
1019newtype ReqBodyJson a = ReqBodyJson a
1243
1020
1244−instance (ToJSON a) => HttpBody (ReqBodyJson a) where
1021+instance ToJSON a => HttpBody (ReqBodyJson a) where
1245 getRequestBody (ReqBodyJson a) = L.RequestBodyLBS (A.encode a)
1022 getRequestBody (ReqBodyJson a) = L.RequestBodyLBS (A.encode a)
1246 getRequestContentType _ = pure "application/json; charset=utf-8"
1023 getRequestContentType _ = pure "application/json; charset=utf-8"
1247
1024
1248-- | This body option streams request body from a file. It is expected that
1025-- | This body option streams request body from a file. It is expected that
1249−-- the file size does not change during streaming.
1026+-- the file size does not change during the streaming.
1250--
1027--
1251-- Using of this body option does not set the @Content-Type@ header.
1028-- Using of this body option does not set the @Content-Type@ header.
1252newtype ReqBodyFile = ReqBodyFile FilePath
1029newtype ReqBodyFile = ReqBodyFile FilePath
@@ -1271,11 +1048,12 @@ newtype ReqBodyLbs = ReqBodyLbs BL.ByteString
1271instance HttpBody ReqBodyLbs where
1048instance HttpBody ReqBodyLbs where
1272 getRequestBody (ReqBodyLbs bs) = L.RequestBodyLBS bs
1049 getRequestBody (ReqBodyLbs bs) = L.RequestBodyLBS bs
1273
1050
1274−-- | URL-encoded body. This can hold a collection of parameters which are
1051+-- | Form URL-encoded body. This can hold a collection of parameters which
1275−-- encoded similarly to query parameters at the end of query string, with
1052+-- are encoded similarly to query parameters at the end of query string,
1276−-- the only difference that they are stored in request body. The similarity
1053+-- with the only difference that they are stored in request body. The
1277−-- is reflected in the API as well, as you can use the same combinators you
1054+-- similarity is reflected in the API as well, as you can use the same
1278−-- would use to add query parameters: @('=:')@ and 'queryFlag'.
1055+-- combinators you would use to add query parameters: @('=:')@ and
1056+-- 'queryFlag'.
1279--
1057--
1280-- This body option sets the @Content-Type@ header to
1058-- This body option sets the @Content-Type@ header to
1281-- @\"application/x-www-form-urlencoded\"@ value.
1059-- @\"application/x-www-form-urlencoded\"@ value.
@@ -1294,13 +1072,6 @@ newtype FormUrlEncodedParam = FormUrlEncodedParam [(Text, Maybe Text)]
1294instance QueryParam FormUrlEncodedParam where
1072instance QueryParam FormUrlEncodedParam where
1295 queryParam name mvalue =
1073 queryParam name mvalue =
1296 FormUrlEncodedParam [(name, toQueryParam <$> mvalue)]
1074 FormUrlEncodedParam [(name, toQueryParam <$> mvalue)]
1297− queryParamToList (FormUrlEncodedParam p) = p
1298−
1299−-- | Use 'formToQuery'.
1300−--
1301−-- @since 3.11.0
1302−instance FromForm FormUrlEncodedParam where
1303− fromForm = Right . formToQuery
1304
1075
1305-- | Multipart form data. Please consult the
1076-- | Multipart form data. Please consult the
1306-- "Network.HTTP.Client.MultipartFormData" module for how to construct
1077-- "Network.HTTP.Client.MultipartFormData" module for how to construct
@@ -1340,7 +1111,7 @@ instance HttpBody ReqBodyMultipart where
1340-- | Create 'ReqBodyMultipart' request body from a collection of 'LM.Part's.
1111-- | Create 'ReqBodyMultipart' request body from a collection of 'LM.Part's.
1341--
1112--
1342-- @since 0.2.0
1113-- @since 0.2.0
1343−reqBodyMultipart :: (MonadIO m) => [LM.Part] -> m ReqBodyMultipart
1114+reqBodyMultipart :: MonadIO m => [LM.Part] -> m ReqBodyMultipart
1344reqBodyMultipart parts = liftIO $ do
1115reqBodyMultipart parts = liftIO $ do
1345 boundary <- LM.webkitBoundary
1116 boundary <- LM.webkitBoundary
1346 body <- LM.renderParts boundary parts
1117 body <- LM.renderParts boundary parts
@@ -1368,6 +1139,9 @@ type family ProvidesBody body :: CanHaveBody where
1368-- | This type function allows any HTTP body if method says it
1139-- | This type function allows any HTTP body if method says it
1369-- 'CanHaveBody'. When the method says it should have 'NoBody', the only
1140-- 'CanHaveBody'. When the method says it should have 'NoBody', the only
1370-- body option to use is 'NoReqBody'.
1141-- body option to use is 'NoReqBody'.
1142+--
1143+-- __Note__: users of GHC 8.0.1 and later will see a slightly more friendly
1144+-- error message when method does not allow a body and body is provided.
1371type family
1145type family
1372 HttpBodyAllowed
1146 HttpBodyAllowed
1373 (allowsBody :: CanHaveBody)
1147 (allowsBody :: CanHaveBody)
@@ -1380,8 +1154,8 @@ type family
1380 TypeError
1154 TypeError
1381 ('Text "This HTTP method does not allow attaching a request body.")
1155 ('Text "This HTTP method does not allow attaching a request body.")
1382
1156
1383−instance (HttpBody body) => RequestComponent (Tagged "body" body) where
1157+instance HttpBody body => RequestComponent (Womb "body" body) where
1384− getRequestMod (Tagged body) = Endo $ \x ->
1158+ getRequestMod (Womb body) = Endo $ \x ->
1385 x
1159 x
1386 { L.requestBody = getRequestBody body,
1160 { L.requestBody = getRequestBody body,
1387 L.requestHeaders =
1161 L.requestHeaders =
@@ -1410,8 +1184,8 @@ data Option (scheme :: Scheme)
1410 = Option (Endo (Y.QueryText, L.Request)) (Maybe (L.Request -> IO L.Request))
1184 = Option (Endo (Y.QueryText, L.Request)) (Maybe (L.Request -> IO L.Request))
1411
1185
1412-- NOTE 'QueryText' is just [(Text, Maybe Text)], we keep it along with
1186-- NOTE 'QueryText' is just [(Text, Maybe Text)], we keep it along with
1413−-- Request to avoid appending to an existing query string in request every
1187+-- Request to avoid appending to existing query string in request every
1414−-- time new parameter is added. The additional Maybe (L.Request -> IO
1188+-- time new parameter is added. Additional Maybe (L.Request -> IO
1415-- L.Request) is a finalizer that will be applied after all other
1189-- L.Request) is a finalizer that will be applied after all other
1416-- transformations. This is for authentication methods that sign requests
1190-- transformations. This is for authentication methods that sign requests
1417-- based on data in Request.
1191-- based on data in Request.
@@ -1426,12 +1200,6 @@ instance Monoid (Option scheme) where
1426 mempty = Option mempty Nothing
1200 mempty = Option mempty Nothing
1427 mappend = (<>)
1201 mappend = (<>)
1428
1202
1429−-- | Use 'formToQuery'.
1430−--
1431−-- @since 3.11.0
1432−instance FromForm (Option scheme) where
1433− fromForm = Right . formToQuery
1434−
1435-- | A helper to create an 'Option' that modifies only collection of query
1203-- | A helper to create an 'Option' that modifies only collection of query
1436-- parameters. This helper is not a part of the public API.
1204-- parameters. This helper is not a part of the public API.
1437withQueryParams :: (Y.QueryText -> Y.QueryText) -> Option scheme
1205withQueryParams :: (Y.QueryText -> Y.QueryText) -> Option scheme
@@ -1450,7 +1218,7 @@ instance RequestComponent (Option scheme) where
1450
1218
1451-- | Finalize given 'L.Request' by applying a finalizer from the given
1219-- | Finalize given 'L.Request' by applying a finalizer from the given
1452-- 'Option' (if it has any).
1220-- 'Option' (if it has any).
1453−finalizeRequest :: (MonadIO m) => Option scheme -> L.Request -> m L.Request
1221+finalizeRequest :: MonadIO m => Option scheme -> L.Request -> m L.Request
1454finalizeRequest (Option _ mfinalizer) = liftIO . fromMaybe pure mfinalizer
1222finalizeRequest (Option _ mfinalizer) = liftIO . fromMaybe pure mfinalizer
1455
1223
1456----------------------------------------------------------------------------
1224----------------------------------------------------------------------------
@@ -1474,7 +1242,7 @@ infix 7 =:
1474(=:) :: (QueryParam param, ToHttpApiData a) => Text -> a -> param
1242(=:) :: (QueryParam param, ToHttpApiData a) => Text -> a -> param
1475name =: value = queryParam name (pure value)
1243name =: value = queryParam name (pure value)
1476
1244
1477−-- | Construct a flag, that is, a valueless query parameter. For example, in
1245+-- | Construct a flag, that is, valueless query parameter. For example, in
1478-- the following URL @\"a\"@ is a flag, while @\"b\"@ is a query parameter
1246-- the following URL @\"a\"@ is a flag, while @\"b\"@ is a query parameter
1479-- with a value:
1247-- with a value:
1480--
1248--
@@ -1483,27 +1251,9 @@ name =: value = queryParam name (pure value)
1483-- This operator is defined in terms of 'queryParam':
1251-- This operator is defined in terms of 'queryParam':
1484--
1252--
1485-- > queryFlag name = queryParam name (Nothing :: Maybe ())
1253-- > queryFlag name = queryParam name (Nothing :: Maybe ())
1486−queryFlag :: (QueryParam param) => Text -> param
1254+queryFlag :: QueryParam param => Text -> param
1487queryFlag name = queryParam name (Nothing :: Maybe ())
1255queryFlag name = queryParam name (Nothing :: Maybe ())
1488
1256
1489−-- | Construct query parameters from a 'ToForm' instance. This function
1490−-- produces the same query params as 'Form.urlEncodeAsFormStable'.
1491−--
1492−-- Note that 'Form.Form' doesn't have the concept of parameters with the
1493−-- empty value (i.e. what you can get by @key =: ""@). If the value is
1494−-- empty, it will be encoded as a valueless parameter (i.e. what you can get
1495−-- by @queryFlag key@).
1496−--
1497−-- @since 3.11.0
1498−formToQuery :: (QueryParam param, Monoid param, ToForm f) => f -> param
1499−formToQuery f = mconcat . fmap toParam . Form.toListStable $ toForm f
1500− where
1501− toParam (key, val) =
1502− queryParam key $
1503− if val == ""
1504− then Nothing
1505− else Just val
1506−
1507-- | A type class for query-parameter-like things. The reason to have an
1257-- | A type class for query-parameter-like things. The reason to have an
1508-- overloaded 'queryParam' is to be able to use it as an 'Option' and as a
1258-- overloaded 'queryParam' is to be able to use it as an 'Option' and as a
1509-- 'FormUrlEncodedParam' when constructing form URL encoded request bodies.
1259-- 'FormUrlEncodedParam' when constructing form URL encoded request bodies.
@@ -1513,17 +1263,11 @@ class QueryParam param where
1513 -- 'Nothing', it won't be included at all (i.e. you create a flag this
1263 -- 'Nothing', it won't be included at all (i.e. you create a flag this
1514 -- way). It's recommended to use @('=:')@ and 'queryFlag' instead of this
1264 -- way). It's recommended to use @('=:')@ and 'queryFlag' instead of this
1515 -- method, because they are easier to read.
1265 -- method, because they are easier to read.
1516− queryParam :: (ToHttpApiData a) => Text -> Maybe a -> param
1266+ queryParam :: ToHttpApiData a => Text -> Maybe a -> param
1517−
1518− -- | Get the query parameter names and values set by 'queryParam'.
1519− --
1520− -- @since 3.11.0
1521− queryParamToList :: param -> [(Text, Maybe Text)]
1522
1267
1523instance QueryParam (Option scheme) where
1268instance QueryParam (Option scheme) where
1524 queryParam name mvalue =
1269 queryParam name mvalue =
1525 withQueryParams ((:) (name, toQueryParam <$> mvalue))
1270 withQueryParams ((:) (name, toQueryParam <$> mvalue))
1526− queryParamToList (Option f _) = fst $ appEndo f ([], L.defaultRequest)
1527
1271
1528----------------------------------------------------------------------------
1272----------------------------------------------------------------------------
1529-- Request—Optional parameters—Headers
1273-- Request—Optional parameters—Headers
@@ -1547,14 +1291,6 @@ attachHeader :: ByteString -> ByteString -> L.Request -> L.Request
1547attachHeader name value x =
1291attachHeader name value x =
1548 x {L.requestHeaders = (CI.mk name, value) : L.requestHeaders x}
1292 x {L.requestHeaders = (CI.mk name, value) : L.requestHeaders x}
1549
1293
1550−-- | Same as 'header', but with redacted values on print.
1551−--
1552−-- @since 3.13.0
1553−headerRedacted :: ByteString -> ByteString -> Option scheme
1554−headerRedacted name value = withRequest $ \x ->
1555− let y = attachHeader name value x
1556− in y {L.redactHeaders = CI.mk name `S.insert` L.redactHeaders y}
1557−
1558----------------------------------------------------------------------------
1294----------------------------------------------------------------------------
1559-- Request—Optional parameters—Cookies
1295-- Request—Optional parameters—Cookies
1560
1296
@@ -1696,7 +1432,7 @@ customAuth = Option mempty . pure
1696
1432
1697-- | Specify the port to connect to explicitly. Normally, 'Url' you use
1433-- | Specify the port to connect to explicitly. Normally, 'Url' you use
1698-- determines the default port: @80@ for HTTP and @443@ for HTTPS. This
1434-- determines the default port: @80@ for HTTP and @443@ for HTTPS. This
1699−-- 'Option' allows us to choose an arbitrary port overwriting the defaults.
1435+-- 'Option' allows to choose an arbitrary port overwriting the defaults.
1700port :: Int -> Option scheme
1436port :: Int -> Option scheme
1701port n = withRequest $ \x ->
1437port n = withRequest $ \x ->
1702 x {L.port = n}
1438 x {L.port = n}
@@ -1711,8 +1447,8 @@ port n = withRequest $ \x ->
1711--
1447--
1712-- > decompress (const True)
1448-- > decompress (const True)
1713decompress ::
1449decompress ::
1714− -- | Predicate that is given MIME type, it returns 'True' when content
1450+ -- | Predicate that is given MIME type, it
1715− -- should be decompressed on the fly.
1451+ -- returns 'True' when content should be decompressed on the fly.
1716 (ByteString -> Bool) ->
1452 (ByteString -> Bool) ->
1717 Option scheme
1453 Option scheme
1718decompress f = withRequest $ \x ->
1454decompress f = withRequest $ \x ->
@@ -1743,7 +1479,6 @@ httpVersion major minor = withRequest $ \x ->
1743
1479
1744-- | Make a request and ignore the body of the response.
1480-- | Make a request and ignore the body of the response.
1745newtype IgnoreResponse = IgnoreResponse (L.Response ())
1481newtype IgnoreResponse = IgnoreResponse (L.Response ())
1746− deriving (Show)
1747
1482
1748instance HttpResponse IgnoreResponse where
1483instance HttpResponse IgnoreResponse where
1749 type HttpResponseBody IgnoreResponse = ()
1484 type HttpResponseBody IgnoreResponse = ()
@@ -1760,9 +1495,8 @@ ignoreResponse = Proxy
1760-- monad in which you use 'req' will determine what to do in the case when
1495-- monad in which you use 'req' will determine what to do in the case when
1761-- parsing fails (the 'JsonHttpException' constructor will be used).
1496-- parsing fails (the 'JsonHttpException' constructor will be used).
1762newtype JsonResponse a = JsonResponse (L.Response a)
1497newtype JsonResponse a = JsonResponse (L.Response a)
1763− deriving (Show)
1764
1498
1765−instance (FromJSON a) => HttpResponse (JsonResponse a) where
1499+instance FromJSON a => HttpResponse (JsonResponse a) where
1766 type HttpResponseBody (JsonResponse a) = a
1500 type HttpResponseBody (JsonResponse a) = a
1767 toVanillaResponse (JsonResponse r) = r
1501 toVanillaResponse (JsonResponse r) = r
1768 getHttpResponse r = do
1502 getHttpResponse r = do
@@ -1780,7 +1514,6 @@ jsonResponse = Proxy
1780-- | Make a request and interpret the body of the response as a strict
1514-- | Make a request and interpret the body of the response as a strict
1781-- 'ByteString'.
1515-- 'ByteString'.
1782newtype BsResponse = BsResponse (L.Response ByteString)
1516newtype BsResponse = BsResponse (L.Response ByteString)
1783− deriving (Show)
1784
1517
1785instance HttpResponse BsResponse where
1518instance HttpResponse BsResponse where
1786 type HttpResponseBody BsResponse = ByteString
1519 type HttpResponseBody BsResponse = ByteString
@@ -1797,7 +1530,6 @@ bsResponse = Proxy
1797-- | Make a request and interpret the body of the response as a lazy
1530-- | Make a request and interpret the body of the response as a lazy
1798-- 'BL.ByteString'.
1531-- 'BL.ByteString'.
1799newtype LbsResponse = LbsResponse (L.Response BL.ByteString)
1532newtype LbsResponse = LbsResponse (L.Response BL.ByteString)
1800− deriving (Show)
1801
1533
1802instance HttpResponse LbsResponse where
1534instance HttpResponse LbsResponse where
1803 type HttpResponseBody LbsResponse = BL.ByteString
1535 type HttpResponseBody LbsResponse = BL.ByteString
@@ -1814,7 +1546,7 @@ lbsResponse = Proxy
1814----------------------------------------------------------------------------
1546----------------------------------------------------------------------------
1815-- Helpers for response interpretations
1547-- Helpers for response interpretations
1816
1548
1817−-- | Fetch beginning of the response and return it together with a new
1549+-- | Fetch beginning of response and return it together with new
1818-- @'L.Response' 'L.BodyReader'@ that can be passed to 'getHttpResponse' and
1550-- @'L.Response' 'L.BodyReader'@ that can be passed to 'getHttpResponse' and
1819-- such.
1551-- such.
1820grabPreview ::
1552grabPreview ::
@@ -1878,14 +1610,14 @@ brReadN br n = go 0 id id
1878
1610
1879-- | Get the response body.
1611-- | Get the response body.
1880responseBody ::
1612responseBody ::
1881− (HttpResponse response) =>
1613+ HttpResponse response =>
1882 response ->
1614 response ->
1883 HttpResponseBody response
1615 HttpResponseBody response
1884responseBody = L.responseBody . toVanillaResponse
1616responseBody = L.responseBody . toVanillaResponse
1885
1617
1886-- | Get the response status code.
1618-- | Get the response status code.
1887responseStatusCode ::
1619responseStatusCode ::
1888− (HttpResponse response) =>
1620+ HttpResponse response =>
1889 response ->
1621 response ->
1890 Int
1622 Int
1891responseStatusCode =
1623responseStatusCode =
@@ -1893,7 +1625,7 @@ responseStatusCode =
1893
1625
1894-- | Get the response status message.
1626-- | Get the response status message.
1895responseStatusMessage ::
1627responseStatusMessage ::
1896− (HttpResponse response) =>
1628+ HttpResponse response =>
1897 response ->
1629 response ->
1898 ByteString
1630 ByteString
1899responseStatusMessage =
1631responseStatusMessage =
@@ -1901,7 +1633,7 @@ responseStatusMessage =
1901
1633
1902-- | Lookup a particular header from a response.
1634-- | Lookup a particular header from a response.
1903responseHeader ::
1635responseHeader ::
1904− (HttpResponse response) =>
1636+ HttpResponse response =>
1905 -- | Response interpretation
1637 -- | Response interpretation
1906 response ->
1638 response ->
1907 -- | Header to lookup
1639 -- | Header to lookup
@@ -1913,7 +1645,7 @@ responseHeader r h =
1913
1645
1914-- | Get the response 'L.CookieJar'.
1646-- | Get the response 'L.CookieJar'.
1915responseCookieJar ::
1647responseCookieJar ::
1916− (HttpResponse response) =>
1648+ HttpResponse response =>
1917 response ->
1649 response ->
1918 L.CookieJar
1650 L.CookieJar
1919responseCookieJar = L.responseCookieJar . toVanillaResponse
1651responseCookieJar = L.responseCookieJar . toVanillaResponse
@@ -1926,9 +1658,9 @@ responseCookieJar = L.responseCookieJar . toVanillaResponse
1926-- To create a new response interpretation you just need to make your data
1658-- To create a new response interpretation you just need to make your data
1927-- type an instance of the 'HttpResponse' type class.
1659-- type an instance of the 'HttpResponse' type class.
1928
1660
1929−-- | A type class for response interpretations. It allows us to describe how
1661+-- | A type class for response interpretations. It allows to describe how to
1930−-- to consume the response from a @'L.Response' 'L.BodyReader'@ and produce
1662+-- consume response from a @'L.Response' 'L.BodyReader'@ and produce the
1931−-- the final result that is to be returned to the user.
1663+-- final result that is to be returned to the user.
1932class HttpResponse response where
1664class HttpResponse response where
1933 -- | The associated type is the type of body that can be extracted from an
1665 -- | The associated type is the type of body that can be extracted from an
1934 -- instance of 'HttpResponse'.
1666 -- instance of 'HttpResponse'.
@@ -1967,16 +1699,6 @@ class HttpResponse response where
1967 acceptHeader :: Proxy response -> Maybe ByteString
1699 acceptHeader :: Proxy response -> Maybe ByteString
1968 acceptHeader Proxy = Nothing
1700 acceptHeader Proxy = Nothing
1969
1701
1970−-- | This instance has been added to make it easier to inspect 'L.Response'
1971−-- using Req's functions like 'responseStatusCode', 'responseStatusMessage',
1972−-- etc.
1973−--
1974−-- @since 3.12.0
1975−instance HttpResponse (L.Response ()) where
1976− type HttpResponseBody (L.Response ()) = ()
1977− toVanillaResponse = id
1978− getHttpResponse = return . void
1979−
1980----------------------------------------------------------------------------
1702----------------------------------------------------------------------------
1981-- Other
1703-- Other
1982
1704
@@ -2002,7 +1724,7 @@ class RequestComponent a where
2002-- method@ and @'HttpBody' body => 'RequestComponent' body@ when it decides
1724-- method@ and @'HttpBody' body => 'RequestComponent' body@ when it decides
2003-- which instance to use (i.e. the constraints are taken into account later,
1725-- which instance to use (i.e. the constraints are taken into account later,
2004-- when instance is already chosen).
1726-- when instance is already chosen).
2005−newtype Tagged (tag :: Symbol) a = Tagged a
1727+newtype Womb (tag :: Symbol) a = Womb a
2006
1728
2007-- | Exceptions that this library throws.
1729-- | Exceptions that this library throws.
2008data HttpException
1730data HttpException
@@ -2011,24 +1733,10 @@ data HttpException
2011 | -- | A wrapper with Aeson-produced 'String' describing why decoding
1733 | -- | A wrapper with Aeson-produced 'String' describing why decoding
2012 -- failed
1734 -- failed
2013 JsonHttpException String
1735 JsonHttpException String
2014− deriving (Show, Generic)
1736+ deriving (Show, Typeable, Generic)
2015
1737
2016instance Exception HttpException
1738instance Exception HttpException
2017
1739
2018−-- | Return 'Just' if the given 'HttpException' is wrapping a http-client's
2019−-- 'L.StatusCodeException'. Otherwise, return 'Nothing'.
2020−--
2021−-- @since 3.12.0
2022−isStatusCodeException :: HttpException -> Maybe (L.Response ())
2023−isStatusCodeException
2024− ( VanillaHttpException
2025− ( L.HttpExceptionRequest
2026− _
2027− (L.StatusCodeException r _)
2028− )
2029− ) = Just r
2030−isStatusCodeException _ = Nothing
2031−
2032-- | A simple type isomorphic to 'Bool' that we only have for better error
1740-- | A simple type isomorphic to 'Bool' that we only have for better error
2033-- messages. We use it as a kind and its data constructors as type-level
1741-- messages. We use it as a kind and its data constructors as type-level
2034-- tags.
1742-- tags.
@@ -2048,4 +1756,11 @@ data Scheme
2048 Http
1756 Http
2049 | -- | HTTPS
1757 | -- | HTTPS
2050 Https
1758 Https
2051− deriving (Eq, Ord, Show, Data, Generic, TH.Lift)
1759+ deriving (Eq, Ord, Show, Data, Typeable, Generic)
1760+
1761+----------------------------------------------------------------------------
1762+-- Constants
1763+
1764+-- | Max length of preview fragment of response body.
1765+bodyPreviewLength :: Num a => a
1766+bodyPreviewLength = 1024
README.md+124−28
@@ -4,8 +4,10 @@
4[![Hackage](https://img.shields.io/hackage/v/req.svg?style=flat)](https://hackage.haskell.org/package/req)
4[![Hackage](https://img.shields.io/hackage/v/req.svg?style=flat)](https://hackage.haskell.org/package/req)
5[![Stackage Nightly](http://stackage.org/package/req/badge/nightly)](http://stackage.org/nightly/package/req)
5[![Stackage Nightly](http://stackage.org/package/req/badge/nightly)](http://stackage.org/nightly/package/req)
6[![Stackage LTS](http://stackage.org/package/req/badge/lts)](http://stackage.org/lts/package/req)
6[![Stackage LTS](http://stackage.org/package/req/badge/lts)](http://stackage.org/lts/package/req)
7−[![CI](https://github.com/mrkkrp/req/actions/workflows/ci.yaml/badge.svg)](https://github.com/mrkkrp/req/actions/workflows/ci.yaml)
7+[![Build Status](https://travis-ci.org/mrkkrp/req.svg?branch=master)](https://travis-ci.org/mrkkrp/req)
8
8
9+* [Motivation and Req vs other libraries](#motivation-and-req-vs-other-libraries)
10+* [Unsolved problems](#unsolved-problems)
9* [Related packages](#related-packages)
11* [Related packages](#related-packages)
10* [Blog posts](#blog-posts)
12* [Blog posts](#blog-posts)
11* [Contribution](#contribution)
13* [Contribution](#contribution)
@@ -41,33 +43,49 @@ main = runReq defaultHttpConfig $ do
41 liftIO $ print (responseBody r :: Value)
43 liftIO $ print (responseBody r :: Value)
42```
44```
43
45
44−Req is an HTTP client library that attempts to be easy-to-use, type-safe,
46+Req is an easy-to-use, type-safe, expandable, high-level HTTP client library
45−and expandable.
47+that just works without any fooling around.
46−
48+
47−“Easy-to-use” means that the library is designed to be beginner-friendly so
49+What does the phrase “easy-to-use” mean? It means that the library is
48−it's simple to add to your monad stack, intuitive to work with,
50+designed to be beginner-friendly so it's simple to add to your monad stack,
49−well-documented, and does not get in your way. Doing HTTP requests is a
51+intuitive to work with, well-documented, and does not get in your way. Doing
50−common task and a Haskell library for this should be approachable and clear
52+HTTP requests is a common task and Haskell library for this should be very
51−to beginners, thus certain compromises were made. For example, one cannot
53+approachable and clear to beginners, thus certain compromises were made. For
52−currently modify `ManagerSettings` of the default manager because the
54+example, one cannot currently modify `ManagerSettings` of the default
53−library always uses the same implicit global manager for simplicity and
55+manager because the library always uses the same implicit global manager for
54−maximal connection sharing. There is a way to use your own manager with
56+simplicity and maximal connection sharing. There is a way to use your own
55−different settings, but it requires more typing.
57+manager with different settings, but it requires a bit more typing.
56−
58+
57−“Type-safe” means that the library tries to eliminate certain classes of
59+“Type-safe” means that the library is protective and eliminates certain
58−errors. For example, we have correct-by-construction URLs; it is guaranteed
60+classes of errors. For example, we have correct-by-construction URLs, it's
59−that the user does not send the request body when using methods like GET or
61+guaranteed that the user does not send the request body when using methods
60−OPTIONS, and the amount of implicit assumptions is minimized by making the
62+like GET or OPTIONS, and the amount of implicit assumptions is minimized by
61−user specify their intentions in an explicit form. For example, it's not
63+making the user specify his/her intentions in an explicit form (for example,
62−possible to avoid specifying the body or the method of a request.
64+it's not possible to avoid specifying the body or method of request).
63Authentication methods that assume HTTPS force the user to use HTTPS at the
65Authentication methods that assume HTTPS force the user to use HTTPS at the
64−type level.
66+type level. The library also carefully hides underlying types from the
65−
67+lower-level `http-client` package because those types are not safe enough
68+(for example `Request` is an instance of `IsString` and, if it's malformed,
69+it will blow up at run-time).
70+
66−“Expandable” refers to the ability to create new components without having
71+“Expandable” refers to the ability to create new components for dealing with
67−to resort to hacking. For example, it's possible to define your own HTTP
72+HTTP without having to resort to ugly hacking. For example, it's possible to
68−methods, create new ways to construct the body of a request, create new
73+define your own HTTP methods, create new ways to construct the body of a
69−authorization options, perform a request in a different way, and create your
74+request, create new authorization options, perform a request in a different
70−own methods to parse a response.
75+way, and create your own methods to parse and represent a response. As the
76+user extends the library to satisfy his/her special needs, the new solutions
77+will work just like the built-ins. However, all of the common cases are also
78+covered by the library out-of-the-box.
79+
80+“High-level” means that there are less details to worry about. The library
81+is a result of my experiences as a Haskell consultant. Working for several
82+clients, who had very different projects, showed me that the library should
83+adapt easily to any particular style of writing Haskell applications. For
84+example, some people prefer throwing exceptions, while others are concerned
85+with purity. Just define `handleHttpException` accordingly when making your
86+monad instance of `MonadHttp` and it will play together seamlessly. Finally,
87+the library cuts down boilerplate considerably, and helps you write concise,
88+easy to read, and maintainable code.
71
89
72The library uses the following mature packages under the hood to guarantee
90The library uses the following mature packages under the hood to guarantee
73you the best experience:
91you the best experience:
@@ -77,11 +95,89 @@ you the best experience:
77* [`http-client-tls`](https://hackage.haskell.org/package/http-client-tls)—TLS
95* [`http-client-tls`](https://hackage.haskell.org/package/http-client-tls)—TLS
78 (HTTPS) support for `http-client`.
96 (HTTPS) support for `http-client`.
79
97
80−It is important to note that since we leverage well-known libraries that the
98+It's important to note that since we leverage well-known libraries that the
81whole Haskell ecosystem uses, there is no risk in using Req. The machinery
99whole Haskell ecosystem uses, there is no risk in using Req. The machinery
82for performing requests is the same as with `http-conduit` and Wreq. The
100for performing requests is the same as with `http-conduit` and Wreq. The
83only difference is the API.
101only difference is the API.
84
102
103+## Motivation and Req vs other libraries
104+
105+*This section is my opinion and it contains criticisms of other well-known
106+libraries. If you're a user/fan of one of these libraries, please remember
107+not to react aggressively and respect the fact that I may have different
108+views on API design from yours.*
109+
110+I have spent time to write the library because sending HTTP requests is a
111+common need, but there is no high-level library for that in Haskell that I
112+could use with pleasure. I'll explain why.
113+
114+First of all, there is `http-client` and `http-client-tls`. They just work.
115+I have no issues with the libraries except that they are too low-level for
116+my taste. Indeed, even the docs say that they are low-level and “intended as
117+a base layer for more user-friendly packages”. This is exactly how I use
118+them in Req, as base level. Req is nothing but a different API to
119+`http-client`, so it only works because of the hard work put into
120+`http-client`.
121+
122+`http-conduit` definitely has its place. For one thing it allows you to
123+stream request and response bodies in constant memory, what other library
124+allows you to do that? On the other hand if you take a look at
125+`Network.HTTP.Simple`, then although it's said that it's a “higher level
126+API”, it's mostly the same as vanilla `http-client` in spirit/approach and
127+just adds `conduit`-powered functions to perform requests and allows to use
128+global implicit `Manager` (Req does the same). If I tried to frame what
129+exactly I don't like about `http-conduit` in words, then it would be “the
130+way requests are constructed”. You *set* parameters instead of *being
131+forced* to declare necessary bits and *being allowed* to declare optional
132+bits in a way that their combination is valid. Also, with `http-conduit` you
133+parse request from a string without the protection of TH that otherwise
134+saves the day as in Yesod.
135+
136+Then there is Wreq. `wreq` [doesn't see much development
137+lately](https://github.com/bos/wreq/issues/93). `wreq` is by itself a weird
138+library, IMO. You have functions per method—not very good, as there may be
139+new methods, like PATCH which is not new but still missing (well, you have
140+`customMethod`, but what is the point of having per-method functions if you
141+have a more general way to use any method? you should be able to just insert
142+methods in the “argument slot” of `customMethod` and end up with a more
143+general solution). Now, every method function has a companion that takes
144+`Options` (like you have `get` and `getWith`). Why the duplication? Where is
145+generality and flexibility? This is not all though, because you cannot
146+really use `get` you see in the main module, because you want to have
147+connection sharing. Wreq's author does not take the gift of automatic
148+connection re-use `Manager` from `http-client` provides, he invents the
149+whole new thing of “sessions”. Only inside a session your connections will
150+be shared and re-used. However with the session stuff you have yet another
151+set of per-method functions like `get` and `getWith`—these are different
152+ones, to be used with sessions! Now if you have a multi-threaded app, here
153+is a surprise for you: you can't share connections between threads as
154+connections are shared only inside of the `withSession` friend and “session
155+will no longer be valid after that function returns”. There are valid uses
156+for sessions, but the point is that they are just too inconvenient for
157+common tasks.
158+
159+I used `servant-client` a couple of times but the amount of boilerplate it
160+requires is frightening. If you have several query parameters, and you use
161+just one of them, you'll have to pass lots of `Nothing`s.
162+
163+## Unsolved problems
164+
165+AWS request signing is problematic because request body can be in the form
166+of an action to execute (and all that “popper” stuff for streaming), not
167+just a `ByteString` and so getting its digest (hash) is not trivial without
168+running the action and consuming body in its entirety before the request in
169+made. In Wreq the author chose to just use `error` when body is not a
170+(strict or lazy) `ByteString`. Maybe it's OK for Wreq, but I don't consider
171+this a proper solution for Req as we support full variety of body options.
172+For example, what if I want to upload 1 Gb file to S3? I want to stream it
173+in constant memory but at the same time I need to calculate its hash before
174+I start streaming. One solution to the problem seems to be in taking the
175+hash explicitly (as an argument of the hypothetical `awsAuth`) and making it
176+a responsibility of the user to calculate the hash correctly. I don't like
177+this because it's not user-friendly. So the question stays open, for now
178+there is no AWS signing functionality provided out-of-the-box. The best
179+solution for talking to AWS is the `amazonka` package so far.
180+
85## Related packages
181## Related packages
86
182
87The following packages are designed to be used with Req:
183The following packages are designed to be used with Req:
Setup.hsnew file+6
@@ -0,0 +1,6 @@
1+module Main (main) where
2+
3+import Distribution.Simple
4+
5+main :: IO ()
6+main = defaultMain
cabal.projectdeleted−4
@@ -1,4 +0,0 @@
1−packages: .
2−tests: True
3−benchmarks: True
4−constraints: req +dev
httpbin-tests/Network/HTTP/ReqSpec.hs+137−160
@@ -1,6 +1,6 @@
1+{-# LANGUAGE CPP #-}
1{-# LANGUAGE DataKinds #-}
2{-# LANGUAGE DataKinds #-}
2{-# LANGUAGE FlexibleInstances #-}
3{-# LANGUAGE FlexibleInstances #-}
3−{-# LANGUAGE LambdaCase #-}
4{-# LANGUAGE OverloadedStrings #-}
4{-# LANGUAGE OverloadedStrings #-}
5{-# LANGUAGE RankNTypes #-}
5{-# LANGUAGE RankNTypes #-}
6{-# OPTIONS_GHC -fno-warn-orphans #-}
6{-# OPTIONS_GHC -fno-warn-orphans #-}
@@ -8,55 +8,53 @@
8module Network.HTTP.ReqSpec (spec) where
8module Network.HTTP.ReqSpec (spec) where
9
9
10import Control.Exception
10import Control.Exception
11−import Control.Monad (forM_)
11+import Control.Monad.Reader
12import Control.Monad.Trans.Control
12import Control.Monad.Trans.Control
13−import Data.Aeson (ToJSON (..), Value (..), object, (.=))
13+import Data.Aeson ((.=), ToJSON (..), Value (..), object)
14−import Data.Aeson qualified as A
14+import qualified Data.Aeson as A
15−import Data.Aeson.KeyMap qualified as Aeson.KeyMap
16−import Data.ByteString qualified as B
15+import qualified Data.ByteString as B
17−import Data.ByteString.Lazy qualified as BL
16+import qualified Data.ByteString.Lazy as BL
18−import Data.Functor.Identity (runIdentity)
17+import qualified Data.HashMap.Strict as HM
19−import Data.Maybe (fromJust)
20import Data.Proxy
18import Data.Proxy
21import Data.Text (Text)
19import Data.Text (Text)
22−import Data.Text qualified as T
20+import qualified Data.Text as T
23−import Data.Text.Encoding qualified as T
21+import qualified Data.Text.Encoding as T
24−import Data.Text.IO qualified as TIO
22+import qualified Data.Text.IO as TIO
25−import Network.HTTP.Client qualified as L
23+import qualified Network.HTTP.Client as L
26−import Network.HTTP.Client.MultipartFormData qualified as LM
24+import qualified Network.HTTP.Client.MultipartFormData as LM
27−import Network.HTTP.Req hiding (req)
25+import Network.HTTP.Req
28−import Network.HTTP.Req qualified as Req
29−import Network.HTTP.Types qualified as Y
26+import qualified Network.HTTP.Types as Y
30import Test.Hspec
27import Test.Hspec
31import Test.QuickCheck
28import Test.QuickCheck
32
29
30+#if !MIN_VERSION_base(4,13,0)
31+import Data.Semigroup ((<>))
32+#endif
33+
33spec :: Spec
34spec :: Spec
34spec = do
35spec = do
35− describe "exception throwing on non-2xx status codes" $
36+ describe "exception throwing on non-2xx status codes"
37+ $ it "throws indeed for non-2xx"
38+ $ req GET (httpbin /: "foo") NoReqBody ignoreResponse mempty
39+ `shouldThrow` selector404
40+
41+ describe "exception throwing on non-2xx status codes (Req monad)"
36− it "throws indeed for non-2xx" $
42+ $ it "throws indeed for non-2xx"
43+ $ asIO . runReq defaultHttpConfig
44+ $ liftBaseWith
45+ $ \run ->
37− req GET (httpbin /: "foo") NoReqBody ignoreResponse mempty
46+ run (req GET (httpbin /: "foo") NoReqBody ignoreResponse mempty)
38 `shouldThrow` selector404
47 `shouldThrow` selector404
39
48
40− describe "exception throwing on non-2xx status codes (Req monad)" $
41− it "throws indeed for non-2xx" $
42− asIO . runReq defaultHttpConfig $
43− liftBaseWith $ \run ->
44− run (req GET (httpbin /: "foo") NoReqBody ignoreResponse mempty)
45− `shouldThrow` selector404
46−
47− describe "response check via httpConfigCheckResponse" $
49+ describe "response check via httpConfigCheckResponse"
48− context "if it's set to always throw" $
50+ $ context "if it's set to always throw"
49− it "throws indeed" $
51+ $ it "throws indeed"
50− blindlyThrowing (req GET httpbin NoReqBody ignoreResponse mempty)
52+ $ blindlyThrowing (req GET httpbin NoReqBody ignoreResponse mempty)
51− `shouldThrow` anyException
53+ `shouldThrow` anyException
52−
54+
53− describe "isStatusCodeException" $
54− it "extracts non-2xx response" $
55− req GET (httpbin /: "foo") NoReqBody ignoreResponse mempty
56− `shouldThrow` selector404ByStatusCodeException
57−
58− describe "receiving user-agent header back" $
55+ describe "receiving user-agent header back"
59− it "works" $ do
56+ $ it "works"
57+ $ do
60 r <-
58 r <-
61 req
59 req
62 GET
60 GET
@@ -70,8 +68,9 @@ spec = do
70 responseStatusCode r `shouldBe` 200
68 responseStatusCode r `shouldBe` 200
71 responseStatusMessage r `shouldBe` "OK"
69 responseStatusMessage r `shouldBe` "OK"
72
70
73− describe "receiving request headers back" $
71+ describe "receiving request headers back"
74− it "works" $ do
72+ $ it "works"
73+ $ do
75 r <-
74 r <-
76 req
75 req
77 GET
76 GET
@@ -85,30 +84,34 @@ spec = do
85 .= object
84 .= object
86 [ "Accept-Encoding" .= ("gzip" :: Text),
85 [ "Accept-Encoding" .= ("gzip" :: Text),
87 "Foo" .= ("bar" :: Text),
86 "Foo" .= ("bar" :: Text),
88− "Baz" .= ("quux" :: Text)
87+ "Baz" .= ("quux" :: Text),
88+ "Host" .= ("httpbin.org" :: Text)
89 ]
89 ]
90 ]
90 ]
91 responseStatusCode r `shouldBe` 200
91 responseStatusCode r `shouldBe` 200
92 responseStatusMessage r `shouldBe` "OK"
92 responseStatusMessage r `shouldBe` "OK"
93
93
94− describe "receiving GET data back" $
94+ describe "receiving GET data back"
95− it "works" $ do
95+ $ it "works"
96+ $ do
96 r <- req GET (httpbin /: "get") NoReqBody jsonResponse mempty
97 r <- req GET (httpbin /: "get") NoReqBody jsonResponse mempty
97 (stripFunnyHeaders . stripOrigin) (responseBody r)
98 (stripFunnyHeaders . stripOrigin) (responseBody r)
98 `shouldBe` object
99 `shouldBe` object
99 [ "args" .= emptyObject,
100 [ "args" .= emptyObject,
100− "url" .= ("http://localhost:1234/get" :: Text),
101+ "url" .= ("https://httpbin.org/get" :: Text),
101 "headers"
102 "headers"
102 .= object
103 .= object
103− [ "Accept-Encoding" .= ("gzip" :: Text)
104+ [ "Accept-Encoding" .= ("gzip" :: Text),
105+ "Host" .= ("httpbin.org" :: Text)
104 ]
106 ]
105 ]
107 ]
106 responseHeader r "Content-Type" `shouldBe` return "application/json"
108 responseHeader r "Content-Type" `shouldBe` return "application/json"
107 responseStatusCode r `shouldBe` 200
109 responseStatusCode r `shouldBe` 200
108 responseStatusMessage r `shouldBe` "OK"
110 responseStatusMessage r `shouldBe` "OK"
109
111
110− describe "receiving POST JSON data back" $
112+ describe "receiving POST JSON data back"
111− it "works" $ do
113+ $ it "works"
114+ $ do
112 let text = "foo" :: Text
115 let text = "foo" :: Text
113 reflected = reflectJSON text
116 reflected = reflectJSON text
114 r <- req POST (httpbin /: "post") (ReqBodyJson text) jsonResponse mempty
117 r <- req POST (httpbin /: "post") (ReqBodyJson text) jsonResponse mempty
@@ -117,11 +120,12 @@ spec = do
117 [ "args" .= emptyObject,
120 [ "args" .= emptyObject,
118 "json" .= text,
121 "json" .= text,
119 "data" .= reflected,
122 "data" .= reflected,
120− "url" .= ("http://localhost:1234/post" :: Text),
123+ "url" .= ("https://httpbin.org/post" :: Text),
121 "headers"
124 "headers"
122 .= object
125 .= object
123 [ "Content-Type" .= ("application/json; charset=utf-8" :: Text),
126 [ "Content-Type" .= ("application/json; charset=utf-8" :: Text),
124 "Accept-Encoding" .= ("gzip" :: Text),
127 "Accept-Encoding" .= ("gzip" :: Text),
128+ "Host" .= ("httpbin.org" :: Text),
125 "Content-Length" .= show (T.length reflected)
129 "Content-Length" .= show (T.length reflected)
126 ],
130 ],
127 "files" .= emptyObject,
131 "files" .= emptyObject,
@@ -131,25 +135,27 @@ spec = do
131 responseStatusCode r `shouldBe` 200
135 responseStatusCode r `shouldBe` 200
132 responseStatusMessage r `shouldBe` "OK"
136 responseStatusMessage r `shouldBe` "OK"
133
137
134− describe "receiving POST data back (multipart form data)" $
138+ describe "receiving POST data back (multipart form data)"
135− it "works" $ do
139+ $ it "works"
140+ $ do
136 body <-
141 body <-
137 reqBodyMultipart
142 reqBodyMultipart
138 [ LM.partBS "foo" "foo data!",
143 [ LM.partBS "foo" "foo data!",
139 LM.partBS "bar" "bar data!"
144 LM.partBS "bar" "bar data!"
140 ]
145 ]
141 r <- req POST (httpbin /: "post") body jsonResponse mempty
146 r <- req POST (httpbin /: "post") body jsonResponse mempty
142− let contentType = fromJust (getRequestContentType body)
147+ let Just contentType = getRequestContentType body
143 (stripFunnyHeaders . stripOrigin) (responseBody r)
148 (stripFunnyHeaders . stripOrigin) (responseBody r)
144 `shouldBe` object
149 `shouldBe` object
145 [ "args" .= emptyObject,
150 [ "args" .= emptyObject,
146 "json" .= Null,
151 "json" .= Null,
147 "data" .= ("" :: Text),
152 "data" .= ("" :: Text),
148− "url" .= ("http://localhost:1234/post" :: Text),
153+ "url" .= ("https://httpbin.org/post" :: Text),
149 "headers"
154 "headers"
150 .= object
155 .= object
151 [ "Content-Type" .= T.decodeUtf8 contentType,
156 [ "Content-Type" .= T.decodeUtf8 contentType,
152 "Accept-Encoding" .= ("gzip" :: Text),
157 "Accept-Encoding" .= ("gzip" :: Text),
158+ "Host" .= ("httpbin.org" :: Text),
153 "Content-Length" .= ("242" :: Text)
159 "Content-Length" .= ("242" :: Text)
154 ],
160 ],
155 "files" .= emptyObject,
161 "files" .= emptyObject,
@@ -163,8 +169,9 @@ spec = do
163 responseStatusCode r `shouldBe` 200
169 responseStatusCode r `shouldBe` 200
164 responseStatusMessage r `shouldBe` "OK"
170 responseStatusMessage r `shouldBe` "OK"
165
171
166− describe "receiving PATCHed file back" $
172+ describe "receiving PATCHed file back"
167− it "works" $ do
173+ $ it "works"
174+ $ do
168 let file :: FilePath
175 let file :: FilePath
169 file = "httpbin-data/robots.txt"
176 file = "httpbin-data/robots.txt"
170 contents <- TIO.readFile file
177 contents <- TIO.readFile file
@@ -174,10 +181,11 @@ spec = do
174 [ "args" .= emptyObject,
181 [ "args" .= emptyObject,
175 "json" .= Null,
182 "json" .= Null,
176 "data" .= contents,
183 "data" .= contents,
177− "url" .= ("http://localhost:1234/patch" :: Text),
184+ "url" .= ("https://httpbin.org/patch" :: Text),
178 "headers"
185 "headers"
179 .= object
186 .= object
180 [ "Accept-Encoding" .= ("gzip" :: Text),
187 [ "Accept-Encoding" .= ("gzip" :: Text),
188+ "Host" .= ("httpbin.org" :: Text),
181 "Content-Length" .= show (T.length contents)
189 "Content-Length" .= show (T.length contents)
182 ],
190 ],
183 "files" .= emptyObject,
191 "files" .= emptyObject,
@@ -187,8 +195,9 @@ spec = do
187 responseStatusCode r `shouldBe` 200
195 responseStatusCode r `shouldBe` 200
188 responseStatusMessage r `shouldBe` "OK"
196 responseStatusMessage r `shouldBe` "OK"
189
197
190− describe "receiving PUT form URL-encoded data back" $
198+ describe "receiving PUT form URL-encoded data back"
191− it "works" $ do
199+ $ it "works"
200+ $ do
192 let params =
201 let params =
193 "foo" =: ("bar" :: Text)
202 "foo" =: ("bar" :: Text)
194 <> "baz" =: (5 :: Int)
203 <> "baz" =: (5 :: Int)
@@ -199,11 +208,12 @@ spec = do
199 [ "args" .= emptyObject,
208 [ "args" .= emptyObject,
200 "json" .= Null,
209 "json" .= Null,
201 "data" .= ("" :: Text),
210 "data" .= ("" :: Text),
202− "url" .= ("http://localhost:1234/put" :: Text),
211+ "url" .= ("https://httpbin.org/put" :: Text),
203 "headers"
212 "headers"
204 .= object
213 .= object
205 [ "Content-Type" .= ("application/x-www-form-urlencoded" :: Text),
214 [ "Content-Type" .= ("application/x-www-form-urlencoded" :: Text),
206 "Accept-Encoding" .= ("gzip" :: Text),
215 "Accept-Encoding" .= ("gzip" :: Text),
216+ "Host" .= ("httpbin.org" :: Text),
207 "Content-Length" .= ("18" :: Text)
217 "Content-Length" .= ("18" :: Text)
208 ],
218 ],
209 "files" .= emptyObject,
219 "files" .= emptyObject,
@@ -220,8 +230,9 @@ spec = do
220
230
221 -- TODO /delete
231 -- TODO /delete
222
232
223− describe "receiving UTF-8 encoded Unicode data" $
233+ describe "receiving UTF-8 encoded Unicode data"
224− it "works" $ do
234+ $ it "works"
235+ $ do
225 r <-
236 r <-
226 req
237 req
227 GET
238 GET
@@ -237,8 +248,9 @@ spec = do
237 -- TODO /gzip
248 -- TODO /gzip
238 -- TODO /deflate
249 -- TODO /deflate
239
250
240− describe "retrying" $
251+ describe "retrying"
241− it "retries as many times as specified" $ do
252+ $ it "retries as many times as specified"
253+ $ do
242 -- FIXME We no longer can count retries because all the functions
254 -- FIXME We no longer can count retries because all the functions
243 -- responsible for controlling retrying are pure now.
255 -- responsible for controlling retrying are pure now.
244 let status = 408 :: Int
256 let status = 408 :: Int
@@ -261,8 +273,9 @@ spec = do
261 -- TODO /response-headers
273 -- TODO /response-headers
262 -- TODO /redirect
274 -- TODO /redirect
263
275
264− describe "redirects" $
276+ describe "redirects"
265− it "follows redirects" $ do
277+ $ it "follows redirects"
278+ $ do
266 r <-
279 r <-
267 req
280 req
268 GET
281 GET
@@ -281,8 +294,9 @@ spec = do
281 let user, password :: Text
294 let user, password :: Text
282 user = "Scooby"
295 user = "Scooby"
283 password = "Doo"
296 password = "Doo"
284− context "when we do not send appropriate basic auth data" $
297+ context "when we do not send appropriate basic auth data"
285− it "fails with 401" $ do
298+ $ it "fails with 401"
299+ $ do
286 r <-
300 r <-
287 prepareForShit $
301 prepareForShit $
288 req
302 req
@@ -293,15 +307,16 @@ spec = do
293 mempty
307 mempty
294 responseStatusCode r `shouldBe` 401
308 responseStatusCode r `shouldBe` 401
295 responseStatusMessage r `shouldBe` "UNAUTHORIZED"
309 responseStatusMessage r `shouldBe` "UNAUTHORIZED"
296− context "when we provide appropriate basic auth data" $
310+ context "when we provide appropriate basic auth data"
297− it "succeeds" $ do
311+ $ it "succeeds"
312+ $ do
298 r <-
313 r <-
299 req
314 req
300 GET
315 GET
301 (httpbin /: "basic-auth" /~ user /~ password)
316 (httpbin /: "basic-auth" /~ user /~ password)
302 NoReqBody
317 NoReqBody
303 ignoreResponse
318 ignoreResponse
304− (basicAuthUnsafe (T.encodeUtf8 user) (T.encodeUtf8 password))
319+ (basicAuth (T.encodeUtf8 user) (T.encodeUtf8 password))
305 responseStatusCode r `shouldBe` 200
320 responseStatusCode r `shouldBe` 200
306 responseStatusMessage r `shouldBe` "OK"
321 responseStatusMessage r `shouldBe` "OK"
307
322
@@ -313,8 +328,9 @@ spec = do
313 -- TODO /range
328 -- TODO /range
314 -- TODO /html
329 -- TODO /html
315
330
316− describe "robots.txt" $
331+ describe "robots.txt"
317− it "works" $ do
332+ $ it "works"
333+ $ do
318 r <- req GET (httpbin /: "robots.txt") NoReqBody bsResponse mempty
334 r <- req GET (httpbin /: "robots.txt") NoReqBody bsResponse mempty
319 robots <- B.readFile "httpbin-data/robots.txt"
335 robots <- B.readFile "httpbin-data/robots.txt"
320 responseBody r `shouldBe` robots
336 responseBody r `shouldBe` robots
@@ -325,8 +341,9 @@ spec = do
325 -- TODO /cache
341 -- TODO /cache
326
342
327 describe "getting random bytes" $ do
343 describe "getting random bytes" $ do
328− it "works" $
344+ it "works"
329− property $ \n' -> do
345+ $ property
346+ $ \n' -> do
330 let n :: Word
347 let n :: Word
331 n = getSmall n'
348 n = getSmall n'
332 r <-
349 r <-
@@ -339,8 +356,9 @@ spec = do
339 responseBody r `shouldSatisfy` ((== n) . fromIntegral . BL.length)
356 responseBody r `shouldSatisfy` ((== n) . fromIntegral . BL.length)
340 responseStatusCode r `shouldBe` 200
357 responseStatusCode r `shouldBe` 200
341 responseStatusMessage r `shouldBe` "OK"
358 responseStatusMessage r `shouldBe` "OK"
342− context "when we try to interpret 1000 random bytes as JSON" $
359+ context "when we try to interpret 1000 random bytes as JSON"
343− it "throws correct exception" $ do
360+ $ it "throws correct exception"
361+ $ do
344 let selector :: HttpException -> Bool
362 let selector :: HttpException -> Bool
345 selector (JsonHttpException _) = True
363 selector (JsonHttpException _) = True
346 selector _ = False
364 selector _ = False
@@ -354,21 +372,22 @@ spec = do
354 mempty
372 mempty
355 `shouldThrow` selector
373 `shouldThrow` selector
356
374
357− describe "streaming random bytes" $
375+ describe "streaming random bytes"
358− it "works" $
376+ $ it "works"
359− property $ \n' -> do
377+ $ property
378+ $ \n' -> do
360− let n :: Word
379+ let n :: Word
361− n = getSmall n'
380+ n = getSmall n'
362− r <-
381+ r <-
363− req
382+ req
364− GET
383+ GET
365− (httpbin /: "stream-bytes" /~ n)
384+ (httpbin /: "stream-bytes" /~ n)
366− NoReqBody
385+ NoReqBody
367− bsResponse
386+ bsResponse
368− mempty
387+ mempty
369− responseBody r `shouldSatisfy` ((== n) . fromIntegral . B.length)
388+ responseBody r `shouldSatisfy` ((== n) . fromIntegral . B.length)
370− responseStatusCode r `shouldBe` 200
389+ responseStatusCode r `shouldBe` 200
371− responseStatusMessage r `shouldBe` "OK"
390+ responseStatusMessage r `shouldBe` "OK"
372
391
373-- TODO /links
392-- TODO /links
374-- TODO /image
393-- TODO /image
@@ -388,87 +407,52 @@ instance MonadHttp IO where
388----------------------------------------------------------------------------
407----------------------------------------------------------------------------
389-- Helpers
408-- Helpers
390
409
391−-- | Run a request with such settings that it does not signal errors.
410+-- | Run request with such settings that it does not signal error on adverse
411+-- response status codes.
392prepareForShit :: Req a -> IO a
412prepareForShit :: Req a -> IO a
393prepareForShit = runReq defaultHttpConfig {httpConfigCheckResponse = noNoise}
413prepareForShit = runReq defaultHttpConfig {httpConfigCheckResponse = noNoise}
394 where
414 where
395 noNoise _ _ _ = Nothing
415 noNoise _ _ _ = Nothing
396
416
397−-- | Run a request with such settings that it throws on any response.
417+-- | Run request with such settings that it throws on any response.
398blindlyThrowing :: Req a -> IO a
418blindlyThrowing :: Req a -> IO a
399blindlyThrowing = runReq defaultHttpConfig {httpConfigCheckResponse = doit}
419blindlyThrowing = runReq defaultHttpConfig {httpConfigCheckResponse = doit}
400 where
420 where
401 doit _ _ = error "Oops!"
421 doit _ _ = error "Oops!"
402
422
403-- | 'Url' representing <https://httpbin.org>.
423-- | 'Url' representing <https://httpbin.org>.
404−httpbin :: Url 'Http
424+httpbin :: Url 'Https
405−httpbin = http "localhost"
425+httpbin = https "httpbin.org"
406−
407−req ::
408− ( MonadHttp m,
409− HttpMethod method,
410− HttpBody body,
411− HttpResponse response,
412− HttpBodyAllowed (AllowsBody method) (ProvidesBody body)
413− ) =>
414− method ->
415− Url scheme ->
416− body ->
417− Proxy response ->
418− Option scheme ->
419− m response
420−req method url body responseProxy options =
421− Req.req method url body responseProxy (options <> defaultOptions)
422−
423−-- | Options to apply by default.
424−defaultOptions :: Option scheme
425−defaultOptions = port 1234
426
426
427-- | Remove “origin” field from JSON value. Origin may change, we don't want
427-- | Remove “origin” field from JSON value. Origin may change, we don't want
428-- to depend on that.
428-- to depend on that.
429stripOrigin :: Value -> Value
429stripOrigin :: Value -> Value
430−stripOrigin (Object m) = Object (Aeson.KeyMap.delete "origin" m)
430+stripOrigin (Object m) = Object (HM.delete "origin" m)
431stripOrigin value = value
431stripOrigin value = value
432
432
433-- | Remove funny headers that might break the tests.
433-- | Remove funny headers that might break the tests.
434stripFunnyHeaders :: Value -> Value
434stripFunnyHeaders :: Value -> Value
435−stripFunnyHeaders = \case
435+stripFunnyHeaders (Object m) =
436− Object m ->
436+ let f (Object p) = Object $ HM.filterWithKey (\k _ -> k `elem` hs) p
437− Object
438− ( runIdentity
439− ( Aeson.KeyMap.alterF
440− (pure . fmap stripFunnyHeaders')
441− "headers"
442− m
443− )
444− )
445− value -> value
446−
447−-- | Similar to 'stripFunnyHeaders', but acts directly on the argument
448−-- without trying to access its "headers" field.
449−stripFunnyHeaders' :: Value -> Value
450−stripFunnyHeaders' = \case
451− Object p ->
452− Object $
453− Aeson.KeyMap.filterWithKey
454− (\k _ -> k `elem` whitelistedHeaders)
455− p
456− value -> value
437+ f value = value
457− where
438+ hs =
458− whitelistedHeaders =
459− [ "Content-Type",
439+ [ "Content-Type",
460− "Accept-Encoding",
440+ "Accept-Encoding",
441+ "Host",
461− "Content-Length",
442+ "Content-Length",
462− "Foo",
443+ "Foo",
463− "Baz"
444+ "Baz"
464− ]
445+ ]
446+ in Object (HM.adjust f "headers" m)
447+stripFunnyHeaders value = value
465
448
466-- | This is a complete test case that makes use of <https://httpbin.org> to
449-- | This is a complete test case that makes use of <https://httpbin.org> to
467-- get various response status codes.
450-- get various response status codes.
468checkStatusCode :: Int -> SpecWith ()
451checkStatusCode :: Int -> SpecWith ()
469checkStatusCode code =
452checkStatusCode code =
470− describe ("receiving status code " ++ show code) $
453+ describe ("receiving status code " ++ show code)
471− it "works" $ do
454+ $ it "works"
455+ $ do
472 r <-
456 r <-
473 prepareForShit $
457 prepareForShit $
474 req
458 req
@@ -491,19 +475,12 @@ selector404
491 L.responseStatus response == Y.status404 && not (B.null chunk)
475 L.responseStatus response == Y.status404 && not (B.null chunk)
492selector404 _ = False
476selector404 _ = False
493
477
494−-- | Same as 'selector404' except that it uses 'isStatusCodeException'.
495−selector404ByStatusCodeException :: HttpException -> Bool
496−selector404ByStatusCodeException e =
497− case isStatusCodeException e of
498− Nothing -> False
499− Just r -> responseStatusCode r == 404
500−
501−-- | The empty JSON 'Object'.
478+-- | Empty JSON 'Object'.
502emptyObject :: Value
479emptyObject :: Value
503−emptyObject = Object Aeson.KeyMap.empty
480+emptyObject = Object HM.empty
504
481
505−-- | Get a rendered JSON value as 'Text'.
482+-- | Get rendered JSON value as 'Text'.
506−reflectJSON :: (ToJSON a) => a -> Text
483+reflectJSON :: ToJSON a => a -> Text
507reflectJSON = T.decodeUtf8 . BL.toStrict . A.encode
484reflectJSON = T.decodeUtf8 . BL.toStrict . A.encode
508
485
509-- | Clarify to the type checker that the inner computation is in the 'IO'
486-- | Clarify to the type checker that the inner computation is in the 'IO'
pure-tests/Network/HTTP/ReqSpec.hs+190−223
@@ -1,3 +1,4 @@
1+{-# LANGUAGE CPP #-}
1{-# LANGUAGE DataKinds #-}
2{-# LANGUAGE DataKinds #-}
2{-# LANGUAGE DeriveGeneric #-}
3{-# LANGUAGE DeriveGeneric #-}
3{-# LANGUAGE FlexibleInstances #-}
4{-# LANGUAGE FlexibleInstances #-}
@@ -7,56 +8,55 @@
7{-# LANGUAGE RankNTypes #-}
8{-# LANGUAGE RankNTypes #-}
8{-# LANGUAGE RecordWildCards #-}
9{-# LANGUAGE RecordWildCards #-}
9{-# LANGUAGE ScopedTypeVariables #-}
10{-# LANGUAGE ScopedTypeVariables #-}
10−{-# LANGUAGE TypeApplications #-}
11{-# LANGUAGE NoMonomorphismRestriction #-}
11{-# LANGUAGE NoMonomorphismRestriction #-}
12{-# OPTIONS_GHC -fno-warn-orphans #-}
12{-# OPTIONS_GHC -fno-warn-orphans #-}
13
13
14module Network.HTTP.ReqSpec (spec) where
14module Network.HTTP.ReqSpec (spec) where
15
15
16−import Blaze.ByteString.Builder qualified as BB
16+import qualified Blaze.ByteString.Builder as BB
17import Control.Exception (throwIO)
17import Control.Exception (throwIO)
18import Control.Monad
18import Control.Monad
19import Control.Retry
19import Control.Retry
20import Data.Aeson (ToJSON (..))
20import Data.Aeson (ToJSON (..))
21−import Data.Aeson qualified as A
21+import qualified Data.Aeson as A
22import Data.ByteString (ByteString)
22import Data.ByteString (ByteString)
23−import Data.ByteString qualified as B
23+import qualified Data.ByteString as B
24−import Data.ByteString.Char8 qualified as B8
24+import qualified Data.ByteString.Char8 as B8
25−import Data.ByteString.Lazy qualified as BL
25+import qualified Data.ByteString.Lazy as BL
26−import Data.CaseInsensitive qualified as CI
26+import qualified Data.CaseInsensitive as CI
27import Data.Either (isRight)
27import Data.Either (isRight)
28−import Data.List.NonEmpty qualified as NE
28+import qualified Data.List.NonEmpty as NE
29−import Data.Maybe (fromJust, fromMaybe, isJust, isNothing)
29+import Data.Maybe (fromJust, fromMaybe, isNothing)
30import Data.Proxy
30import Data.Proxy
31import Data.Text (Text)
31import Data.Text (Text)
32−import Data.Text qualified as T
32+import qualified Data.Text as T
33−import Data.Text.Encoding qualified as T
33+import qualified Data.Text.Encoding as T
34import Data.Time
34import Data.Time
35−import Data.Typeable (Typeable, eqT)
36−import GHC.Exts (IsList (..))
37import GHC.Generics
35import GHC.Generics
38−import Language.Haskell.TH qualified as TH
39−import Language.Haskell.TH.Quote qualified as TH
40−import Network.HTTP.Client qualified as L
36+import qualified Network.HTTP.Client as L
41import Network.HTTP.Req
37import Network.HTTP.Req
42−import Network.HTTP.Types qualified as Y
38+import qualified Network.HTTP.Types as Y
43−import Network.HTTP.Types.Header qualified as Y
39+import qualified Network.HTTP.Types.Header as Y
44import Test.Hspec
40import Test.Hspec
45import Test.Hspec.Core.Spec (SpecM)
41import Test.Hspec.Core.Spec (SpecM)
46import Test.QuickCheck
42import Test.QuickCheck
47import Text.URI (URI)
43import Text.URI (URI)
48−import Text.URI qualified as URI
44+import qualified Text.URI as URI
49−import Text.URI.QQ qualified as QQ
45+import qualified Text.URI.QQ as QQ
50−import Web.FormUrlEncoded qualified as F
46+
47+#if !MIN_VERSION_base(4,13,0)
48+import Data.Semigroup ((<>))
49+#endif
51
50
52spec :: Spec
51spec :: Spec
53spec = do
52spec = do
54− describe "config" $
53+ describe "config"
55− it "getHttpConfig has effect on resulting request" $
54+ $ it "getHttpConfig has effect on resulting request"
56− property $ \config -> do
55+ $ property
56+ $ \config -> do
57− request <- runReq config (req_ GET url NoReqBody mempty)
57+ request <- runReq config (req_ GET url NoReqBody mempty)
58− L.proxy request `shouldBe` httpConfigProxy config
58+ L.proxy request `shouldBe` httpConfigProxy config
59− L.redirectCount request `shouldBe` httpConfigRedirectCount config
59+ L.redirectCount request `shouldBe` httpConfigRedirectCount config
60
60
61 describe "methods" $ do
61 describe "methods" $ do
62 let mnth ::
62 let mnth ::
@@ -68,8 +68,9 @@ spec = do
68 SpecM () ()
68 SpecM () ()
69 mnth method = do
69 mnth method = do
70 let name = httpMethodName (Proxy :: Proxy method)
70 let name = httpMethodName (Proxy :: Proxy method)
71− describe (B8.unpack name) $
71+ describe (B8.unpack name)
72− it "affects name of HTTP method" $ do
72+ $ it "affects name of HTTP method"
73+ $ do
73 request <- req_ method url NoReqBody mempty
74 request <- req_ method url NoReqBody mempty
74 L.method request `shouldBe` name
75 L.method request `shouldBe` name
75 mnth GET
76 mnth GET
@@ -83,42 +84,48 @@ spec = do
83 mnth PATCH
84 mnth PATCH
84
85
85 describe "urls" $ do
86 describe "urls" $ do
86− describe "http" $
87+ describe "http"
87− it "sets all the params correctly" $
88+ $ it "sets all the params correctly"
89+ $ property
88− property $ \host -> do
90+ $ \host -> do
89− request <- req_ GET (http host) NoReqBody mempty
91+ request <- req_ GET (http host) NoReqBody mempty
90− L.secure request `shouldBe` False
92+ L.secure request `shouldBe` False
91− L.port request `shouldBe` 80
93+ L.port request `shouldBe` 80
92− L.host request `shouldBe` urlEncode host
94+ L.host request `shouldBe` urlEncode host
93− describe "https" $
95+ describe "https"
94− it "sets all the params correctly" $
96+ $ it "sets all the params correctly"
97+ $ property
95− property $ \host -> do
98+ $ \host -> do
96− request <- req_ GET (https host) NoReqBody mempty
99+ request <- req_ GET (https host) NoReqBody mempty
97− L.secure request `shouldBe` True
100+ L.secure request `shouldBe` True
98− L.port request `shouldBe` 443
101+ L.port request `shouldBe` 443
99− L.host request `shouldBe` urlEncode host
102+ L.host request `shouldBe` urlEncode host
100− describe "(/~)" $
103+ describe "(/~)"
101− it "attaches a path piece that is URL-encoded" $
104+ $ it "attaches a path piece that is URL-encoded"
105+ $ property
102− property $ \host pieces -> do
106+ $ \host pieces -> do
103− let url' = foldl (/~) (https host) pieces
107+ let url' = foldl (/~) (https host) pieces
104− request <- req_ GET url' NoReqBody mempty
108+ request <- req_ GET url' NoReqBody mempty
105− L.host request `shouldBe` urlEncode host
109+ L.host request `shouldBe` urlEncode host
106− L.path request `shouldBe` encodePathPieces pieces
110+ L.path request `shouldBe` encodePathPieces pieces
107− describe "(/:)" $
111+ describe "(/:)"
108− it "attaches a path piece that is URL-encoded" $
112+ $ it "attaches a path piece that is URL-encoded"
113+ $ property
109− property $ \host pieces -> do
114+ $ \host pieces -> do
110− let url' = foldl (/:) (https host) pieces
115+ let url' = foldl (/:) (https host) pieces
111− request <- req_ GET url' NoReqBody mempty
116+ request <- req_ GET url' NoReqBody mempty
112− L.host request `shouldBe` urlEncode host
117+ L.host request `shouldBe` urlEncode host
113− L.path request `shouldBe` encodePathPieces pieces
118+ L.path request `shouldBe` encodePathPieces pieces
114
119
115 describe "useHttpURI" $ do
120 describe "useHttpURI" $ do
116− it "does not recognize non-http schemes" $
121+ it "does not recognize non-http schemes"
117− property $ \uri ->
122+ $ property
123+ $ \uri ->
118 when (URI.uriScheme uri /= Just [QQ.scheme|http|]) $
124 when (URI.uriScheme uri /= Just [QQ.scheme|http|]) $
119 useHttpURI uri `shouldSatisfy` isNothing
125 useHttpURI uri `shouldSatisfy` isNothing
120− it "accepts correct URLs" $
126+ it "accepts correct URLs"
121− property $ \uri' -> do
127+ $ property
128+ $ \uri' -> do
122 unless (isRight (URI.uriAuthority uri')) discard
129 unless (isRight (URI.uriAuthority uri')) discard
123 let uri = uri' {URI.uriScheme = Just [QQ.scheme|http|]}
130 let uri = uri' {URI.uriScheme = Just [QQ.scheme|http|]}
124 (url', options) = fromJust (useHttpURI uri)
131 (url', options) = fromJust (useHttpURI uri)
@@ -130,12 +137,14 @@ spec = do
130 lookup "Authorization" (L.requestHeaders request)
137 lookup "Authorization" (L.requestHeaders request)
131 `shouldBe` uriBasicAuth uri
138 `shouldBe` uriBasicAuth uri
132 describe "useHttpsURI" $ do
139 describe "useHttpsURI" $ do
133− it "does not recognize non-https schemes" $
140+ it "does not recognize non-https schemes"
134− property $ \uri ->
141+ $ property
142+ $ \uri ->
135 when (URI.uriScheme uri /= Just [QQ.scheme|https|]) $
143 when (URI.uriScheme uri /= Just [QQ.scheme|https|]) $
136 useHttpsURI uri `shouldSatisfy` isNothing
144 useHttpsURI uri `shouldSatisfy` isNothing
137− it "parses correct URLs" $
145+ it "parses correct URLs"
138− property $ \uri' -> do
146+ $ property
147+ $ \uri' -> do
139 unless (isRight (URI.uriAuthority uri')) discard
148 unless (isRight (URI.uriAuthority uri')) discard
140 let uri = uri' {URI.uriScheme = Just [QQ.scheme|https|]}
149 let uri = uri' {URI.uriScheme = Just [QQ.scheme|https|]}
141 (url', options) = fromJust (useHttpsURI uri)
150 (url', options) = fromJust (useHttpsURI uri)
@@ -147,27 +156,27 @@ spec = do
147 lookup "Authorization" (L.requestHeaders request)
156 lookup "Authorization" (L.requestHeaders request)
148 `shouldBe` uriBasicAuth uri
157 `shouldBe` uriBasicAuth uri
149 describe "useURI" $ do
158 describe "useURI" $ do
150− it "does not recognize non-http and non-https schemes" $
159+ it "does not recognize non-http and non-https schemes"
151− property $ \uri ->
160+ $ property
161+ $ \uri ->
152 when
162 when
153 ( ( URI.uriScheme uri /= Just [QQ.scheme|http|]
163 ( ( URI.uriScheme uri /= Just [QQ.scheme|http|]
154 && (URI.uriScheme uri /= Just [QQ.scheme|https|])
164 && (URI.uriScheme uri /= Just [QQ.scheme|https|])
155 )
165 )
156 )
166 )
157 $ useURI uri `shouldSatisfy` isNothing
167 $ useURI uri `shouldSatisfy` isNothing
158− it "parses correct URLs" $
168+ it "parses correct URLs"
159− property $ \uri' -> do
169+ $ property
170+ $ \uri' -> do
160 unless (isRight (URI.uriAuthority uri')) discard
171 unless (isRight (URI.uriAuthority uri')) discard
161 let uriHttp = uri' {URI.uriScheme = Just [QQ.scheme|http|]}
172 let uriHttp = uri' {URI.uriScheme = Just [QQ.scheme|http|]}
162 uriHttps = uri' {URI.uriScheme = Just [QQ.scheme|https|]}
173 uriHttps = uri' {URI.uriScheme = Just [QQ.scheme|https|]}
163 requestHttp <-
174 requestHttp <-
164− case fromJust (useURI uriHttp) of
175+ let Left (url', options) = fromJust (useURI uriHttp)
165− Left (url', options) -> req_ GET url' NoReqBody options
176+ in req_ GET url' NoReqBody options
166− _ -> error "(useURI uriHttp) should have returned Left"
167 requestHttps <-
177 requestHttps <-
168− case fromJust (useURI uriHttps) of
178+ let Right (url', options) = fromJust (useURI uriHttps)
169− Right (url', options) -> req_ GET url' NoReqBody options
179+ in req_ GET url' NoReqBody options
170− _ -> error "(useURI uriHttps) should have returned Right"
171 L.host requestHttp `shouldBe` uriHost uriHttp
180 L.host requestHttp `shouldBe` uriHost uriHttp
172 L.host requestHttps `shouldBe` uriHost uriHttps
181 L.host requestHttps `shouldBe` uriHost uriHttps
173 L.port requestHttp `shouldBe` uriPort 80 uriHttp
182 L.port requestHttp `shouldBe` uriPort 80 uriHttp
@@ -181,83 +190,57 @@ spec = do
181 lookup "Authorization" (L.requestHeaders requestHttps)
190 lookup "Authorization" (L.requestHeaders requestHttps)
182 `shouldBe` uriBasicAuth uriHttps
191 `shouldBe` uriBasicAuth uriHttps
183
192
184− describe "renderUrl" $ do
185− context "http" $ do
186− context "empty path" $
187− it "renders correctly" $ do
188− let (uriHttp, _) = [urlQ|http://httpbin.org|]
189− renderUrl uriHttp `shouldBe` "http://httpbin.org"
190− context "non-empty path" $
191− it "renders correctly" $ do
192− let (uriHttp, _) = [urlQ|http://httpbin.org/here/we/go|]
193− renderUrl uriHttp `shouldBe` "http://httpbin.org/here/we/go"
194− context "http" $ do
195− context "empty path" $
196− it "renders correctly" $ do
197− let (uriHttp, _) = [urlQ|https://httpbin.org|]
198− renderUrl uriHttp `shouldBe` "https://httpbin.org"
199− context "non-empty path" $
200− it "renders correctly" $ do
201− let (uriHttp, _) = [urlQ|https://httpbin.org/here/we/go|]
202− renderUrl uriHttp `shouldBe` "https://httpbin.org/here/we/go"
203−
204 describe "bodies" $ do
193 describe "bodies" $ do
205− describe "NoReqBody" $
194+ describe "NoReqBody"
206− it "sets body to empty byte string" $ do
195+ $ it "sets body to empty byte string"
196+ $ do
207 request <- req_ POST url NoReqBody mempty
197 request <- req_ POST url NoReqBody mempty
208 case L.requestBody request of
198 case L.requestBody request of
209 L.RequestBodyBS x -> x `shouldBe` B.empty
199 L.RequestBodyBS x -> x `shouldBe` B.empty
210 _ -> expectationFailure "Wrong request body constructor."
200 _ -> expectationFailure "Wrong request body constructor."
211− describe "ReqBodyJson" $
201+ describe "ReqBodyJson"
212− it "sets body to correct lazy byte string" $
202+ $ it "sets body to correct lazy byte string"
203+ $ property
213− property $ \thing -> do
204+ $ \thing -> do
214− request <- req_ POST url (ReqBodyJson thing) mempty
205+ request <- req_ POST url (ReqBodyJson thing) mempty
215− case L.requestBody request of
206+ case L.requestBody request of
216− L.RequestBodyLBS x -> x `shouldBe` A.encode (thing :: Thing)
207+ L.RequestBodyLBS x -> x `shouldBe` A.encode (thing :: Thing)
217− _ -> expectationFailure "Wrong request body constructor."
208+ _ -> expectationFailure "Wrong request body constructor."
218− describe "ReqBodyBs" $
209+ describe "ReqBodyBs"
219− it "sets body to specified strict byte string" $
210+ $ it "sets body to specified strict byte string"
211+ $ property
220− property $ \bs -> do
212+ $ \bs -> do
221− request <- req_ POST url (ReqBodyBs bs) mempty
213+ request <- req_ POST url (ReqBodyBs bs) mempty
222− case L.requestBody request of
214+ case L.requestBody request of
223− L.RequestBodyBS x -> x `shouldBe` bs
215+ L.RequestBodyBS x -> x `shouldBe` bs
224− _ -> expectationFailure "Wrong request body constructor."
216+ _ -> expectationFailure "Wrong request body constructor."
225− describe "ReqBodyLbs" $
217+ describe "ReqBodyLbs"
226− it "sets body to specified lazy byte string" $
218+ $ it "sets body to specified lazy byte string"
219+ $ property
227− property $ \lbs -> do
220+ $ \lbs -> do
228− request <- req_ POST url (ReqBodyLbs lbs) mempty
221+ request <- req_ POST url (ReqBodyLbs lbs) mempty
229− case L.requestBody request of
222+ case L.requestBody request of
230− L.RequestBodyLBS x -> x `shouldBe` lbs
223+ L.RequestBodyLBS x -> x `shouldBe` lbs
231− _ -> expectationFailure "Wrong request body constructor."
224+ _ -> expectationFailure "Wrong request body constructor."
232− describe "ReqBodyUrlEnc" $
225+ describe "ReqBodyUrlEnc"
233− it "sets body to correct lazy byte string" $
226+ $ it "sets body to correct lazy byte string"
227+ $ property
234− property $ \params -> do
228+ $ \params -> do
235− request <- req_ POST url (ReqBodyUrlEnc (formUrlEnc params)) mempty
229+ request <- req_ POST url (ReqBodyUrlEnc (formUrlEnc params)) mempty
236− case L.requestBody request of
230+ case L.requestBody request of
237− L.RequestBodyLBS x -> x `shouldBe` renderQuery params
231+ L.RequestBodyLBS x -> x `shouldBe` renderQuery params
238− _ -> expectationFailure "Wrong request body constructor."
239−
240− describe "query params" $ do
241− describe "FormUrlEncodedParam" $ do
242− describe "formToQuery" $ do
243− it "should produce the same parameters as F.urlEncodeFormStable" $
244− property $ \form -> do
245− request <- req_ POST url (ReqBodyUrlEnc $ formToQuery form) mempty
246− case L.requestBody request of
247− L.RequestBodyLBS x -> x `shouldBe` F.urlEncodeFormStable form
248− _ -> expectationFailure "Wrong request body constructor"
232+ _ -> expectationFailure "Wrong request body constructor."
249− specParamToList (Proxy :: Proxy FormUrlEncodedParam)
250− describe "Option" $ do
251− specParamToList (Proxy :: Proxy (Option 'Http))
252
233
253 describe "optional parameters" $ do
234 describe "optional parameters" $ do
254 describe "header" $ do
235 describe "header" $ do
255− it "sets specified header value" $
236+ it "sets specified header value"
237+ $ property
256− property $ \name value -> do
238+ $ \name value -> do
257 request <- req_ GET url NoReqBody (header name value)
239 request <- req_ GET url NoReqBody (header name value)
258 lookup (CI.mk name) (L.requestHeaders request) `shouldBe` pure value
240 lookup (CI.mk name) (L.requestHeaders request) `shouldBe` pure value
259− it "left header wins" $
241+ it "left header wins"
242+ $ property
260− property $ \name value0 value1 -> do
243+ $ \name value0 value1 -> do
261 request <-
244 request <-
262 req_
245 req_
263 GET
246 GET
@@ -265,8 +248,9 @@ spec = do
265 NoReqBody
248 NoReqBody
266 (header name value0 <> header name value1)
249 (header name value0 <> header name value1)
267 lookup (CI.mk name) (L.requestHeaders request) `shouldBe` pure value0
250 lookup (CI.mk name) (L.requestHeaders request) `shouldBe` pure value0
268− it "overwrites headers set by other parts of the lib" $
251+ it "overwrites headers set by other parts of the lib"
269− property $ \value -> do
252+ $ property
253+ $ \value -> do
270 request <-
254 request <-
271 req_
255 req_
272 POST
256 POST
@@ -274,19 +258,22 @@ spec = do
274 (ReqBodyUrlEnc mempty)
258 (ReqBodyUrlEnc mempty)
275 (header "Content-Type" value)
259 (header "Content-Type" value)
276 lookup "Content-Type" (L.requestHeaders request) `shouldBe` pure value
260 lookup "Content-Type" (L.requestHeaders request) `shouldBe` pure value
277− describe "cookieJar" $
261+ describe "cookieJar"
278− it "cookie jar is set without modifications" $
262+ $ it "cookie jar is set without modifications"
279− property $ \cjar -> do
263+ $ property
264+ $ \cjar -> do
280− request <- req_ GET url NoReqBody (cookieJar cjar)
265+ request <- req_ GET url NoReqBody (cookieJar cjar)
281− L.cookieJar request `shouldSatisfy` (maybe False (L.equalCookieJar cjar))
266+ L.cookieJar request `shouldBe` pure cjar
282 describe "basicAuth" $ do
267 describe "basicAuth" $ do
283− it "sets Authorization header to correct value" $
268+ it "sets Authorization header to correct value"
269+ $ property
284− property $ \username password -> do
270+ $ \username password -> do
285 request <- req_ GET url NoReqBody (basicAuth username password)
271 request <- req_ GET url NoReqBody (basicAuth username password)
286 lookup "Authorization" (L.requestHeaders request)
272 lookup "Authorization" (L.requestHeaders request)
287 `shouldBe` Just (basicAuthHeader username password)
273 `shouldBe` Just (basicAuthHeader username password)
288− it "overwrites manual setting of header" $
274+ it "overwrites manual setting of header"
275+ $ property
289− property $ \username password value -> do
276+ $ \username password value -> do
290 request0 <-
277 request0 <-
291 req_
278 req_
292 GET
279 GET
@@ -302,8 +289,9 @@ spec = do
302 let result = Just (basicAuthHeader username password)
289 let result = Just (basicAuthHeader username password)
303 lookup "Authorization" (L.requestHeaders request0) `shouldBe` result
290 lookup "Authorization" (L.requestHeaders request0) `shouldBe` result
304 lookup "Authorization" (L.requestHeaders request1) `shouldBe` result
291 lookup "Authorization" (L.requestHeaders request1) `shouldBe` result
305− it "left auth option wins" $
292+ it "left auth option wins"
293+ $ property
306− property $ \username0 password0 username1 password1 -> do
294+ $ \username0 password0 username1 password1 -> do
307 request <-
295 request <-
308 req_
296 req_
309 GET
297 GET
@@ -313,13 +301,15 @@ spec = do
313 lookup "Authorization" (L.requestHeaders request)
301 lookup "Authorization" (L.requestHeaders request)
314 `shouldBe` Just (basicAuthHeader username0 password0)
302 `shouldBe` Just (basicAuthHeader username0 password0)
315 describe "oAuth2Bearer" $ do
303 describe "oAuth2Bearer" $ do
316− it "sets Authorization header to correct value" $
304+ it "sets Authorization header to correct value"
317− property $ \token -> do
305+ $ property
306+ $ \token -> do
318 request <- req_ GET url NoReqBody (oAuth2Bearer token)
307 request <- req_ GET url NoReqBody (oAuth2Bearer token)
319 lookup "Authorization" (L.requestHeaders request)
308 lookup "Authorization" (L.requestHeaders request)
320 `shouldBe` pure ("Bearer " <> token)
309 `shouldBe` pure ("Bearer " <> token)
321− it "overwrites manual setting of header" $
310+ it "overwrites manual setting of header"
311+ $ property
322− property $ \token value -> do
312+ $ \token value -> do
323 request0 <-
313 request0 <-
324 req_
314 req_
325 GET
315 GET
@@ -337,8 +327,9 @@ spec = do
337 `shouldBe` pure result
327 `shouldBe` pure result
338 lookup "Authorization" (L.requestHeaders request1)
328 lookup "Authorization" (L.requestHeaders request1)
339 `shouldBe` pure result
329 `shouldBe` pure result
340− it "left auth option wins" $
330+ it "left auth option wins"
331+ $ property
341− property $ \token0 token1 -> do
332+ $ \token0 token1 -> do
342 request <-
333 request <-
343 req_
334 req_
344 GET
335 GET
@@ -347,20 +338,23 @@ spec = do
347 (oAuth2Bearer token0 <> oAuth2Bearer token1)
338 (oAuth2Bearer token0 <> oAuth2Bearer token1)
348 lookup "Authorization" (L.requestHeaders request)
339 lookup "Authorization" (L.requestHeaders request)
349 `shouldBe` pure ("Bearer " <> token0)
340 `shouldBe` pure ("Bearer " <> token0)
350− describe "ProxyAuthorization" $
341+ describe "ProxyAuthorization"
351− it "sets Authorization header to correct value" $
342+ $ it "sets Authorization header to correct value"
343+ $ property
352− property $ \username password -> do
344+ $ \username password -> do
353− request <- req_ GET url NoReqBody (basicProxyAuth username password)
345+ request <- req_ GET url NoReqBody (basicProxyAuth username password)
354− lookup "Proxy-Authorization" (L.requestHeaders request)
346+ lookup "Proxy-Authorization" (L.requestHeaders request)
355− `shouldBe` pure (basicProxyAuthHeader username password)
347+ `shouldBe` pure (basicProxyAuthHeader username password)
356 describe "oAuth2Token" $ do
348 describe "oAuth2Token" $ do
357− it "sets Authorization header to correct value" $
349+ it "sets Authorization header to correct value"
358− property $ \token -> do
350+ $ property
351+ $ \token -> do
359 request <- req_ GET url NoReqBody (oAuth2Token token)
352 request <- req_ GET url NoReqBody (oAuth2Token token)
360 lookup "Authorization" (L.requestHeaders request)
353 lookup "Authorization" (L.requestHeaders request)
361 `shouldBe` pure ("token " <> token)
354 `shouldBe` pure ("token " <> token)
362− it "overwrites manual setting of header" $
355+ it "overwrites manual setting of header"
356+ $ property
363− property $ \token value -> do
357+ $ \token value -> do
364 request0 <-
358 request0 <-
365 req_
359 req_
366 GET
360 GET
@@ -378,8 +372,9 @@ spec = do
378 `shouldBe` pure result
372 `shouldBe` pure result
379 lookup "Authorization" (L.requestHeaders request1)
373 lookup "Authorization" (L.requestHeaders request1)
380 `shouldBe` pure result
374 `shouldBe` pure result
381− it "left auth option wins" $
375+ it "left auth option wins"
376+ $ property
382− property $ \token0 token1 -> do
377+ $ \token0 token1 -> do
383 request <-
378 request <-
384 req_
379 req_
385 GET
380 GET
@@ -388,37 +383,27 @@ spec = do
388 (oAuth2Token token0 <> oAuth2Token token1)
383 (oAuth2Token token0 <> oAuth2Token token1)
389 lookup "Authorization" (L.requestHeaders request)
384 lookup "Authorization" (L.requestHeaders request)
390 `shouldBe` pure ("token " <> token0)
385 `shouldBe` pure ("token " <> token0)
391− describe "port" $
386+ describe "port"
392− it "sets port overwriting the defaults" $
387+ $ it "sets port overwriting the defaults"
388+ $ property
393− property $ \n -> do
389+ $ \n -> do
394− request <- req_ GET url NoReqBody (port n)
390+ request <- req_ GET url NoReqBody (port n)
395− L.port request `shouldBe` n
391+ L.port request `shouldBe` n
396− describe "decompress" $
392+ describe "decompress"
397− it "sets decompress function overwriting the defaults" $
393+ $ it "sets decompress function overwriting the defaults"
394+ $ property
398− property $ \token -> do
395+ $ \token -> do
399− request <- req_ GET url NoReqBody (decompress (/= token))
396+ request <- req_ GET url NoReqBody (decompress (/= token))
400− L.decompress request token `shouldBe` False
397+ L.decompress request token `shouldBe` False
401 -- FIXME Can't really test responseTimeout right new because the
398 -- FIXME Can't really test responseTimeout right new because the
402 -- ResponseTimeout data type does not implement Eq and its constructors
399 -- ResponseTimeout data type does not implement Eq and its constructors
403 -- are also not exported. Sent a PR.
400 -- are also not exported. Sent a PR.
404− describe "httpVersion" $
401+ describe "httpVersion"
405− it "sets HTTP version overwriting the defaults" $
402+ $ it "sets HTTP version overwriting the defaults"
403+ $ property
406− property $ \major minor -> do
404+ $ \major minor -> do
407− request <- req_ GET url NoReqBody (httpVersion major minor)
405+ request <- req_ GET url NoReqBody (httpVersion major minor)
408− L.requestVersion request `shouldBe` Y.HttpVersion major minor
406+ L.requestVersion request `shouldBe` Y.HttpVersion major minor
409−
410− describe "quasiquoter" $ do
411− it "works for valid urls" $
412− -- Doing it this way instead of just checking if [urlQ|...|] :: (Url
413− -- 'Https, Option _) type checks, so we can catch if the type of scheme
414− -- is unspecified.
415− let testTypeOfQuoterResult ::
416− forall a s. (Typeable a) => (a, Option s) -> Bool
417− testTypeOfQuoterResult _ = isJust $ eqT @a @(Url 'Https)
418− in property $ testTypeOfQuoterResult [urlQ|https://example.org/|]
419− it "doesn't work for invalid urls" $
420− property $
421− TH.runQ (TH.quoteExp urlQ "not a url") `shouldThrow` anyIOException
422
407
423----------------------------------------------------------------------------
408----------------------------------------------------------------------------
424-- Instances
409-- Instances
@@ -434,8 +419,6 @@ instance Arbitrary HttpConfig where
434 httpConfigCheckResponse _ _ _ = Nothing
419 httpConfigCheckResponse _ _ _ = Nothing
435 httpConfigRetryPolicy = retryPolicyDefault
420 httpConfigRetryPolicy = retryPolicyDefault
436 httpConfigRetryJudge _ _ = False
421 httpConfigRetryJudge _ _ = False
437− httpConfigRetryJudgeException _ _ = False
438− httpConfigBodyPreviewLength = 1024
439 return HttpConfig {..}
422 return HttpConfig {..}
440
423
441instance Show HttpConfig where
424instance Show HttpConfig where
@@ -503,9 +486,6 @@ instance Arbitrary Day where
503instance Arbitrary DiffTime where
486instance Arbitrary DiffTime where
504 arbitrary = secondsToDiffTime <$> arbitrary
487 arbitrary = secondsToDiffTime <$> arbitrary
505
488
506−instance Arbitrary F.Form where
507− arbitrary = (F.Form . fromList) <$> arbitrary
508−
509----------------------------------------------------------------------------
489----------------------------------------------------------------------------
510-- Helper types
490-- Helper types
511
491
@@ -573,14 +553,13 @@ uriPort def uri =
573 maybe def (fromIntegral) $
553 maybe def (fromIntegral) $
574 either (const Nothing) Just (URI.uriAuthority uri) >>= URI.authPort
554 either (const Nothing) Just (URI.uriAuthority uri) >>= URI.authPort
575
555
576−-- | Get the path from a 'URI'.
556+-- | Get path from 'URI'.
577uriPath :: URI -> ByteString
557uriPath :: URI -> ByteString
578uriPath uri = fromMaybe "" $ do
558uriPath uri = fromMaybe "" $ do
579− (trailingSlash, xs) <- URI.uriPath uri
559+ (_, xs) <- URI.uriPath uri
580− let pref = (encodePathPieces . fmap URI.unRText . NE.toList) xs
560+ (return . encodePathPieces . fmap URI.unRText . NE.toList) xs
581− return $ if trailingSlash then pref <> "/" else pref
582
561
583−-- | Get the query string from a 'URI'.
562+-- | Get query string from 'URI'.
584uriQuery :: URI -> ByteString
563uriQuery :: URI -> ByteString
585uriQuery uri = do
564uriQuery uri = do
586 let liftQueryParam = \case
565 let liftQueryParam = \case
@@ -618,15 +597,3 @@ basicProxyAuthHeader :: ByteString -> ByteString -> ByteString
618basicProxyAuthHeader username password =
597basicProxyAuthHeader username password =
619 fromJust . lookup Y.hProxyAuthorization . L.requestHeaders $
598 fromJust . lookup Y.hProxyAuthorization . L.requestHeaders $
620 L.applyBasicProxyAuth username password L.defaultRequest
599 L.applyBasicProxyAuth username password L.defaultRequest
621−
622−-- | Spec about 'paramToList' for the type @p@.
623−specParamToList :: (QueryParam p, Monoid p) => Proxy p -> Spec
624−specParamToList typeProxy = do
625− describe "paramToList" $ do
626− it "should reproduce the parameters given by queryParam" $
627− property $ \(QueryParams params) -> do
628− let queryParam0 =
629− (mconcat $ fmap (uncurry queryParam) params)
630− `asProxyTypeOf` typeProxy
631− got = queryParamToList queryParam0
632− got `shouldBe` params
req.cabal+68−68
@@ -1,15 +1,19 @@
1−cabal-version: 2.4
1+cabal-version: 1.18
2name: req
2name: req
3−version: 3.13.4
3+version: 3.1.0
4−license: BSD-3-Clause
4+license: BSD3
5license-file: LICENSE.md
5license-file: LICENSE.md
6maintainer: Mark Karpov <markkarpov92@gmail.com>
6maintainer: Mark Karpov <markkarpov92@gmail.com>
7author: Mark Karpov <markkarpov92@gmail.com>
7author: Mark Karpov <markkarpov92@gmail.com>
8−tested-with: ghc ==9.6.3 ghc ==9.8.2 ghc ==9.10.1
8+tested-with: ghc ==8.6.5 ghc ==8.8.3 ghc ==8.10.1
9homepage: https://github.com/mrkkrp/req
9homepage: https://github.com/mrkkrp/req
10bug-reports: https://github.com/mrkkrp/req/issues
10bug-reports: https://github.com/mrkkrp/req/issues
11−synopsis: HTTP client library
11+synopsis:
12+ Easy-to-use, type-safe, expandable, high-level HTTP client library
13+
12−description: HTTP client library.
14+description:
15+ Easy-to-use, type-safe, expandable, high-level HTTP client library.
16+
13category: Network, Web
17category: Network, Web
14build-type: Simple
18build-type: Simple
15data-files:
19data-files:
@@ -31,97 +35,93 @@ flag dev
31
35
32library
36library
33 exposed-modules: Network.HTTP.Req
37 exposed-modules: Network.HTTP.Req
34− default-language: GHC2021
38+ default-language: Haskell2010
35 build-depends:
39 build-depends:
36− aeson >=0.9 && <3,
40+ aeson >=0.9 && <1.5,
37− authenticate-oauth >=1.5 && <1.8,
41+ authenticate-oauth >=1.5 && <1.7,
38− base >=4.15 && <5,
42+ base >=4.12 && <5.0,
39 blaze-builder >=0.3 && <0.5,
43 blaze-builder >=0.3 && <0.5,
40− bytestring >=0.10.8 && <0.13,
44+ bytestring >=0.10.8 && <0.11,
41 case-insensitive >=0.2 && <1.3,
45 case-insensitive >=0.2 && <1.3,
42− containers >=0.5 && <0.8,
43− crypton-connection >=0.4.2 && <0.5,
46+ connection >=0.2.2 && <0.4,
44− data-default-class >=0.2.0.0,
45− exceptions >=0.6 && <0.11,
46− http-api-data >=0.2 && <0.7,
47+ http-api-data >=0.2 && <0.5,
47− http-client >=0.7.13.1 && <0.8,
48+ http-client >=0.5 && <0.7,
48 http-client-tls >=0.3.2 && <0.4,
49 http-client-tls >=0.3.2 && <0.4,
49− http-types >=0.8 && <10,
50+ http-types >=0.8 && <10.0,
50 modern-uri >=0.3 && <0.4,
51 modern-uri >=0.3 && <0.4,
51 monad-control >=1.0 && <1.1,
52 monad-control >=1.0 && <1.1,
52 mtl >=2.0 && <3.0,
53 mtl >=2.0 && <3.0,
53− retry >=0.8 && <0.10,
54+ retry >=0.8 && <0.9,
54− template-haskell >=2.19 && <2.23,
55+ text >=0.2 && <1.3,
55− text >=0.2 && <2.2,
56+ time >=1.2 && <1.10,
56− transformers >=0.5.3.0 && <0.7,
57+ transformers >=0.4 && <0.6,
57− transformers-base,
58+ transformers-base -any
58− unliftio-core >=0.1.1 && <0.3
59
59
60 if flag(dev)
60 if flag(dev)
61− ghc-options:
61+ ghc-options: -O0 -Wall -Werror
62− -Wall -Werror -Wpartial-fields -Wunused-packages
63− -Wno-unused-imports
64
62
65 else
63 else
66 ghc-options: -O2 -Wall
64 ghc-options: -O2 -Wall
67
65
66+ if flag(dev)
67+ ghc-options:
68+ -Wcompat -Wincomplete-record-updates -Wincomplete-uni-patterns
69+ -Wnoncanonical-monad-instances
70+
68test-suite pure-tests
71test-suite pure-tests
69− type: exitcode-stdio-1.0
72+ type: exitcode-stdio-1.0
70− main-is: Spec.hs
73+ main-is: Spec.hs
71− build-tool-depends: hspec-discover:hspec-discover >=2 && <3
74+ build-tools: hspec-discover >=2.0 && <3.0
72− hs-source-dirs: pure-tests
75+ hs-source-dirs: pure-tests
73− other-modules: Network.HTTP.ReqSpec
76+ other-modules: Network.HTTP.ReqSpec
74− default-language: GHC2021
77+ default-language: Haskell2010
75 build-depends:
78 build-depends:
76− QuickCheck >=2.7 && <3,
79+ QuickCheck >=2.7 && <3.0,
77− aeson >=0.9 && <3,
80+ aeson >=0.9 && <1.5,
78− base >=4.15 && <5.0,
81+ base >=4.12 && <5.0,
79 blaze-builder >=0.3 && <0.5,
82 blaze-builder >=0.3 && <0.5,
80− bytestring >=0.10.8 && <0.13,
83+ bytestring >=0.10.8 && <0.11,
81 case-insensitive >=0.2 && <1.3,
84 case-insensitive >=0.2 && <1.3,
82− hspec >=2.0 && <3,
85+ hspec >=2.0 && <3.0,
83− hspec-core >=2.0 && <3,
86+ hspec-core >=2.0 && <3.0,
84− http-api-data >=0.2 && <0.7,
85− http-client >=0.7 && <0.8,
87+ http-client >=0.5 && <0.7,
86− http-types >=0.8 && <10,
88+ http-types >=0.8 && <10.0,
87 modern-uri >=0.3 && <0.4,
89 modern-uri >=0.3 && <0.4,
90+ mtl >=2.0 && <3.0,
88− req,
91+ req -any,
89− retry >=0.8 && <0.10,
92+ retry >=0.8 && <0.9,
90− template-haskell >=2.19 && <2.23,
91− text >=0.2 && <2.2,
93+ text >=0.2 && <1.3,
92− time >=1.2 && <1.15
94+ time >=1.2 && <1.10
93
95
94 if flag(dev)
96 if flag(dev)
95− ghc-options:
97+ ghc-options: -O0 -Wall -Werror
96− -Wall -Werror -Wredundant-constraints -Wpartial-fields
97− -Wunused-packages
98
98
99 else
99 else
100 ghc-options: -O2 -Wall
100 ghc-options: -O2 -Wall
101
101
102test-suite httpbin-tests
102test-suite httpbin-tests
103− type: exitcode-stdio-1.0
103+ type: exitcode-stdio-1.0
104− main-is: Spec.hs
104+ main-is: Spec.hs
105− build-tool-depends: hspec-discover:hspec-discover >=2 && <3
105+ build-tools: hspec-discover >=2.0 && <3.0
106− hs-source-dirs: httpbin-tests
106+ hs-source-dirs: httpbin-tests
107− other-modules: Network.HTTP.ReqSpec
107+ other-modules: Network.HTTP.ReqSpec
108− default-language: GHC2021
108+ default-language: Haskell2010
109 build-depends:
109 build-depends:
110− QuickCheck >=2.7 && <3,
110+ QuickCheck >=2.7 && <3.0,
111− aeson >=2 && <3,
111+ aeson >=0.9 && <1.5,
112− base >=4.15 && <5,
112+ base >=4.12 && <5.0,
113− bytestring >=0.10.8 && <0.13,
113+ bytestring >=0.10.8 && <0.11,
114 hspec >=2.0 && <3.0,
114 hspec >=2.0 && <3.0,
115− http-client >=0.7 && <0.8,
115+ http-client >=0.5 && <0.7,
116− http-types >=0.8 && <10,
116+ http-types >=0.8 && <10.0,
117 monad-control >=1.0 && <1.1,
117 monad-control >=1.0 && <1.1,
118+ mtl >=2.0 && <3.0,
118− req,
119+ req -any,
119− text >=0.2 && <2.2
120+ text >=0.2 && <1.3,
121+ unordered-containers >=0.2.5 && <0.2.11
120
122
121 if flag(dev)
123 if flag(dev)
122− ghc-options:
124+ ghc-options: -O0 -Wall -Werror
123− -Wall -Werror -Wredundant-constraints -Wpartial-fields
124− -Wunused-packages
125
125
126 else
126 else
127− buildable: False
127+ ghc-options: -O2 -Wall