Safe Haskell	Safe-Inferred
Language	Haskell98

Network.HTTP.Types.URI

Contents

Query string
- Escape only parts
- Text query string (UTF8 encoded)
Path segments
Path (segments + query string)
URL encoding / decoding

Synopsis

type QueryItem = ( ByteString , Maybe ByteString )
type Query = [ QueryItem ]
type SimpleQueryItem = ( ByteString , ByteString )
type SimpleQuery = [ SimpleQueryItem ]
simpleQueryToQuery :: SimpleQuery -> Query
renderQuery :: Bool -> Query -> ByteString
renderQueryBuilder :: Bool -> Query -> Builder
renderSimpleQuery :: Bool -> SimpleQuery -> ByteString
parseQuery :: ByteString -> Query
parseQueryReplacePlus :: Bool -> ByteString -> Query
parseSimpleQuery :: ByteString -> SimpleQuery
renderQueryPartialEscape :: Bool -> PartialEscapeQuery -> ByteString
renderQueryBuilderPartialEscape :: Bool -> PartialEscapeQuery -> Builder
data EscapeItem
- = QE ByteString
- | QN ByteString
type PartialEscapeQueryItem = ( ByteString , [ EscapeItem ])
type PartialEscapeQuery = [ PartialEscapeQueryItem ]
type QueryText = [( Text , Maybe Text )]
queryTextToQuery :: QueryText -> Query
queryToQueryText :: Query -> QueryText
renderQueryText :: Bool -> QueryText -> Builder
parseQueryText :: ByteString -> QueryText
encodePathSegments :: [ Text ] -> Builder
decodePathSegments :: ByteString -> [ Text ]
encodePathSegmentsRelative :: [ Text ] -> Builder
extractPath :: ByteString -> ByteString
encodePath :: [ Text ] -> Query -> Builder
decodePath :: ByteString -> ([ Text ], Query )
urlEncodeBuilder :: Bool -> ByteString -> Builder
urlEncode :: Bool -> ByteString -> ByteString
urlDecode :: Bool -> ByteString -> ByteString

Query string

type QueryItem = ( ByteString , Maybe ByteString ) Source #

Query item

type Query = [ QueryItem ] Source #

Query.

General form: a=b&c=d , but if the value is Nothing, it becomes a&c=d .

type SimpleQueryItem = ( ByteString , ByteString ) Source #

Simplified Query item type without support for parameter-less items.

type SimpleQuery = [ SimpleQueryItem ] Source #

Simplified Query type without support for parameter-less items.

simpleQueryToQuery :: SimpleQuery -> Query Source #

Convert SimpleQuery to Query .

renderQuery Source #

Arguments

:: Bool	prepend question mark?
-> Query
-> ByteString

Convert Query to ByteString .

renderQueryBuilder Source #

Arguments

:: Bool	prepend a question mark?
-> Query
-> Builder

Convert Query to a Builder .

renderSimpleQuery Source #

Arguments

:: Bool	prepend question mark?
-> SimpleQuery
-> ByteString

Convert SimpleQuery to ByteString .

parseQuery :: ByteString -> Query Source #

Split out the query string into a list of keys and values. A few importants points:

The result returned is still bytestrings, since we perform no character decoding here. Most likely, you will want to use UTF-8 decoding, but this is left to the user of the library.
Percent decoding errors are ignored. In particular, "%Q" will be output as "%Q" .
It decodes '+' characters to ' '

parseQueryReplacePlus :: Bool -> ByteString -> Query Source #

Same functionality as parseQuery with the option to decode '+' characters to ' ' or preserve '+'

parseSimpleQuery :: ByteString -> SimpleQuery Source #

Parse SimpleQuery from a ByteString .

Escape only parts

renderQueryPartialEscape Source #

Arguments

:: Bool	prepend question mark?
-> PartialEscapeQuery
-> ByteString

Convert PartialEscapeQuery to ByteString .

renderQueryBuilderPartialEscape Source #

Arguments

:: Bool	prepend a question mark?
-> PartialEscapeQuery
-> Builder

Convert PartialEscapeQuery to a Builder .

data EscapeItem Source #

For some URIs characters must not be URI encoded, e.g. '+' or ':' in q=a+language:haskell+created:2009-01-01..2009-02-01&sort=stars The character list unreservedPI instead of unreservedQS would solve this. But we explicitly decide what part to encode. This is mandatory when searching for '+' : q=%2B+language:haskell .

Constructors

QE ByteString
QN ByteString

Instances

Instances details

Eq EscapeItem Source #
Instance details Defined in Network.HTTP.Types.URI Methods (==) :: EscapeItem -> EscapeItem -> Bool Source # (/=) :: EscapeItem -> EscapeItem -> Bool Source #
Ord EscapeItem Source #
Instance details Defined in Network.HTTP.Types.URI Methods compare :: EscapeItem -> EscapeItem -> Ordering Source # (<) :: EscapeItem -> EscapeItem -> Bool Source # (<=) :: EscapeItem -> EscapeItem -> Bool Source # (>) :: EscapeItem -> EscapeItem -> Bool Source # (>=) :: EscapeItem -> EscapeItem -> Bool Source # max :: EscapeItem -> EscapeItem -> EscapeItem Source # min :: EscapeItem -> EscapeItem -> EscapeItem Source #
Show EscapeItem Source #
Instance details Defined in Network.HTTP.Types.URI Methods showsPrec :: Int -> EscapeItem -> ShowS Source # show :: EscapeItem -> String Source # showList :: [ EscapeItem ] -> ShowS Source #

type PartialEscapeQueryItem = ( ByteString , [ EscapeItem ]) Source #

Query item

type PartialEscapeQuery = [ PartialEscapeQueryItem ] Source #

Query with some chars that should not be escaped.

General form: a=b&c=d:e+f&g=h

Text query string (UTF8 encoded)

type QueryText = [( Text , Maybe Text )] Source #

Like Query, but with Text instead of ByteString (UTF8-encoded).

queryTextToQuery :: QueryText -> Query Source #

Convert QueryText to Query .

queryToQueryText :: Query -> QueryText Source #

Convert Query to QueryText (leniently decoding the UTF-8).

renderQueryText Source #

Arguments

:: Bool	prepend a question mark?
-> QueryText
-> Builder

Convert QueryText to a Builder .

parseQueryText :: ByteString -> QueryText Source #

Parse QueryText from a ByteString . See parseQuery for details.

Path segments

encodePathSegments :: [ Text ] -> Builder Source #

Encodes a list of path segments into a valid URL fragment.

This function takes the following three steps:

UTF-8 encodes the characters.
Performs percent encoding on all unreserved characters, as well as :@=+$ ,
Prepends each segment with a slash.

For example:

encodePathSegments [\"foo\", \"bar\", \"baz\"]

"/foo/bar/baz"

encodePathSegments [\"foo bar\", \"baz\/bin\"]

"/foo%20bar/baz%2Fbin"

encodePathSegments [\"שלום\"]

"/%D7%A9%D7%9C%D7%95%D7%9D"

Huge thanks to Jeremy Shaw who created the original implementation of this function in web-routes and did such thorough research to determine all correct escaping procedures.

decodePathSegments :: ByteString -> [ Text ] Source #

Parse a list of path segments from a valid URL fragment.

encodePathSegmentsRelative :: [ Text ] -> Builder Source #

Like encodePathSegments, but without the initial slash.

Path (segments + query string)

extractPath :: ByteString -> ByteString Source #

Extract whole path (path segments + query) from a RFC 2616 Request-URI .

>>> extractPath "/path"
"/path"

>>> extractPath "http://example.com:8080/path"
"/path"

>>> extractPath "http://example.com"
"/"

>>> extractPath ""
"/"

encodePath :: [ Text ] -> Query -> Builder Source #

Encode a whole path (path segments + query).

decodePath :: ByteString -> ([ Text ], Query ) Source #

Decode a whole path (path segments + query).

URL encoding / decoding

urlEncodeBuilder Source #

Arguments

:: Bool	Whether input is in query string. True: Query string, False: Path element
-> ByteString
-> Builder

Percent-encoding for URLs (using Builder ).

urlEncode Source #

Arguments

:: Bool	Whether to decode `'+'` to `' '`
-> ByteString	The ByteString to encode as URL
-> ByteString	The encoded URL

Percent-encoding for URLs.

urlDecode Source #

Arguments

:: Bool	Whether to decode `'+'` to `' '`
-> ByteString
-> ByteString

Percent-decoding.