        (if-not (find-ns ns-sym)
          (require ns-sym))
        (catch Exception e
-              (throw (ex-info "failed to require ns in namespace-dispatch-table"
-                              {:context-pathvec context-pathvec
-                               :ns              ns-sym
-                               :middleware      middleware}
-                              e))))
+         (throw (ex-info "failed to require ns in namespace-dispatch-table"
+                         {:context-pathvec context-pathvec
+                          :ns              ns-sym
+                          :middleware      middleware}
+                         e))))
      [(->> ns-sym
            ns-publics
            (keep (fn [[k v]]
                    (if (ifn? @v)
                      (t/track #(format "Building route mapping for `%s/%s'." ns-sym k)
-                       (if-let [route-spec (or (:route-spec (meta v))
-                                               (path-spec->route-spec
-                                                 (:path-spec (meta v)))
-                                               (get default-mappings k))]
-                         (conj route-spec (symbol (name ns-sym) (name k))))))))
+                              (if-let [route-spec (or (:route-spec (meta v))
+                                                      (path-spec->route-spec
+                                                        (:path-spec (meta v)))
+                                                      (get default-mappings k))]
+                                (conj route-spec (symbol (name ns-sym) (name k))))))))
            (list* context-pathvec middleware)
            vec)])))
 

  (let [arg-symbol (symbol-for-argument arg)
        arg-meta (meta arg-symbol)]
    (t/track #(format "Identifying argument resolver for `%s'." arg-symbol)
      (cond
        ;; route param resolution takes precedence
        (contains? route-params arg)
        (make-route-param-resolver arg-symbol)

        ;; explicit ::rook/resolver metadata takes precedence for non-route params
        (contains? arg-meta :io.aviso.rook/resolver)
        (find-resolver arg-resolvers arg-symbol (:io.aviso.rook/resolver arg-meta))

        :else
        (if-let [resolver-tag (find-argument-resolver-tag
                                arg-resolvers arg-symbol arg-meta)]
          ;; explicit tags attached to the arg symbol itself come next
          (find-resolver arg-resolvers arg-symbol resolver-tag)

          ;; non-route-param name-based resolution is implicit and
          ;; should not override explicit tags, so this check comes
          ;; last; NB. the value at arg-symbol might be a keyword
          ;; identifying a resolver factory, so we still need to call
          ;; find-resolver
          (if (contains? arg-resolvers arg-symbol)
            (find-resolver arg-resolvers arg-symbol (get arg-resolvers arg-symbol))

            ;; only static resolution is supported
            (throw (ex-info
                     (format "Unable to identify argument resolver for symbol `%s'." arg-symbol)
                     {:symbol        arg-symbol
                      :symbol-meta   arg-meta
                      :route-params  route-params
                      :arg-resolvers arg-resolvers}))))))))

(defn- create-arglist-resolver
  "Returns a function that is passed the Ring request and returns an array of argument values which

            [clojure.string :as string]
            [clojure.set :as set]
            [io.aviso.tracker :as t]
            [io.aviso.rook.internals :as internals :refer [consume]]
            [clojure.string :as str]
            [clojure.tools.logging :as l]
            [io.aviso.rook.utils :as utils]))
