added in 0.7.0

If true, then the routing table is printed to the console at startup, and when it changes.

Defaults to dev-mode?.


(decode-query-part string)

Decodes one key or value of URL-encoded UTF-8 characters in a URL query string.


(encode-query-part string)

Encodes one key or value for a UTF-8 URL-encoded query string. Encodes space as +.


(expand-routes route-spec)

Given a value (the route specification), produce and return a routing table, a seq of verbose routing maps. The routing table can then be converted to a Router using a number of routing algorithms.

A route specification is any type that satisfies ExpandableRoutes; this includes Clojure vectors, maps, and sets (for terse, table, and verbose routes).

Ensures the integrity of expanded routes (even if they’ve already been checked):

  • Constraints are correctly ordered (most specific to least specific)
  • Route names are unique



A protocol extended onto types that can be used to convert instances into a seq of verbose route maps, the routing table.

Built-in implementations map vectors to terse-routes, sets to table-routes, and maps to map-routes->vec-routes.



(-expand-routes expandable-route-spec)

Generate and return the routing table from a given expandable form of routing data.


(form-action-for-routes routes & default-options)

Like ‘url-for-routes’ but the returned function returns a map with the keys :action, the URL string; and :method, the HTTP verb as a lower-case string. Also, the :method-param is :_method by default, so HTTP verbs other than GET and POST will be converted to POST with the actual verb in the query string.


(method-param)(method-param query-param-or-param-path)

Returns an interceptor that smuggles HTTP verbs through a value in the request. Must come after the interceptor that populates that value (e.g. query-params or body-params).

query-param-or-param-path may be one of two things:

The path :query-params :_method is used by default.


(parse-param-map m)


(parse-path-params request)


(parse-query-params request)


(parse-query-string string & options)

Parses URL query string (not including the leading ‘?’) into1 a map. options are key-value pairs, valid options are:

:key-fn Function to call on parameter keys (after URL decoding), returns key for the map, default converts to a keyword.

:value-fn Function to call on the key (after passing through key-fn) and parameter value (after URL decoding), returns value for the map, default does nothing.


An Interceptor which URL-decodes path parameters. The path parameters are in the :request map as :path-parameters.

This will only operate once per interceptor chain execution, even if it appears multiple times; this prevents failures in existing applications that upgrade to Pedestal 0.6.0, as prior releases incorrectly failed to parse path parameters. Existing applications that upgrade may have this interceptor in some routes, which could yield runtime exceptions and request failures if the interceptor is executed twice.


(print-routes expanded-routes)

Prints a route table (from expand-routes) in an easier to read format.


An interceptor which parses query-string parameters from an HTTP request into a map. Keys in the map are query-string parameter names, as keywords, and values are strings. The map is assoc’d into the request at :query-params.


(router routing-table)(router routing-table router-type)

Given the expanded routing table and, optionally, what kind of router to construct, creates and returns a router interceptor.

router-type may be a keyword identifying a known implementation (see router-implementations), or function that accepts a routing table, and returns a Router.

The default router type is :map-tree, which is the fastest built-in router; however, if the expanded routes contain path parameters or wildcards, the result is equivalent to the slower :prefix-tree implementation.


Maps from the common router implementations (:map-tree, :prefix-tree, or :linear-search) to a router constructor function (which accepts expanded routes, and returns a Router instance).





(router-spec routing-table router-ctor)

Given a routing-table (usually, via expand-routes and a routing contructor functions, returns an interceptor which attempts to match each route against a :request in context. For the first route that matches, it will:

  • enqueue the matched route’s interceptors
  • associate the route into the context as key :route
  • associate a map of :path-params into the :request

If no route matches, returns the context with :route nil.



added in 0.7.0

(routes-from route-spec-expr)

Wraps around an expression that provides the routing specification.

In production mode (the default) evaluates to the expression, unchanged.

In development mode (see dev-mode?), evaluates to a function that, when invoked, returns the expression passed through expand-routes; this is to support a REPL workflow. This works in combination with the extension of RouterSpecification onto Fn, which requires that the returned routing specification be expanded.

Further, when the expression is a non-local symbol, it is assumed to identify a Var holding the unexpanded routing specification; to avoid capturing the Var’s value, the expansion de-references the named Var before passing it to expand-routes.


(try-routing-for routing-table router-type path verb)

Used for testing; constructs a router from the routing-table and router-type and performs routing on the provided path and verb (e.g., :get or :post).

Returns the matched route (a map from the routing table), or nil if routing was unsuccessful.


(url-for route-name & options)

Used by an invoked interceptor (including a handler function) to generate URLs based on a known route name (from the routing specification), and additional data.

This uses a hidden dynamic variable, so it can only be invoked from request processing threads, and only after the routing interceptor has routed the request.

The available options are as described in url-for-routes.


(url-for-routes routes & default-options)

Returns a function that generates URL routes (as strings) from the routes table. The returned function has the signature:

    [route-name & options]

Where options are key-value pairs:

Key Value Description
:app-name String Application name specified for this route
:request Map The original request; it will be merged into the generated link
:params Map A map of all parameters; any params not used as path parameters will be added to the query string
:path-params Map A map of path parameters only
:strict-path-params? Boolean When true will throw an exception if all path-params aren’t fulfilled for the URL
:query-params Map A map of query-string parameters only
:method-param Keyword Names the query-string parameter in which to place the HTTP method name (used when not :get or :post)
:context varied String, function that returns a string, or symbol that resolves to a function; specifies root context for the URL
:fragment String The fragment part of the URL
:absolute? Boolean True to force an absolute URL
:scheme :http or :https Used to override the scheme portion of the URL
:host String Used to override the host portion of the URL
:port Integer Used to override the port in the URL

In addition, you may supply default-options to the ‘url-for-routes’ function, which are merged with the options supplied to the returned function.