Gjør jeg ikke det sneaky trikset må jeg restarte systemet for å få oppdatert handleren, som er litt kjedelig. Jeg kan gå andre veien og slå sammen all rutingen i en funksjon (som er “varifisert”) slik at den bare kan sendes til repl’et, men da blir systemet litt mer sammenkoblet, som er noe jeg håper å unngå

Jeg tror jeg har et eksempel:

(ns clojure-web-template.core
  (:gen-class) ; for -main method in uberjar
  (:require
    [config.core :refer [env reload-env]]
    [io.pedestal.http]
    [integrant.core :as ig]
    [integrant.repl :refer [clear go halt prep init reset reset-all]]
    [integrant.repl.state :refer [system]]
    [io.pedestal.log :as log]))

(defn service-config []
  (reload-env)
  {:clojure-web-template.services.web/service {}})

(integrant.repl/set-prep! service-config)

(ig/load-namespaces (service-config))

(defonce app-started? (atom false))

(when (and (not @app-started?) (not= "prod" :mode env))
  (reset! app-started? true)
  (go))

(defn -main
  [& args]
  (log/info :msg "Starting app...")
  (let [p (promise)]
    (go)
    @p))

(ns clojure-web-template.services.web
  (:require
    [config.core :refer [env]]
    [integrant.core :as ig]
    [io.pedestal.http :as http]
    [io.pedestal.log :as log]
    [io.pedestal.interceptor :as interceptor]
    [io.pedestal.http.route :as route]
    [io.pedestal.http.body-params :as body-params]
    [ring.util.response :as ring-resp]
    [ring.util.response :as ring-response]
    [hiccup2.core :refer [html]])
  (:import (clojure.lang IDeref)))

(defn about-page
  [request]
  (ring-resp/response (format "Clojure %s - served from %s"
                              (clojure-version)
                              (route/url-for ::about-page))))

(defn home-page
  [request]
  (ring-response/response
    (str
      (html
        {:mode :xhtml}
        [:html
         [:head
          [:meta {:charset "utf-8"}]
          [:title "App"]
          [:link {:rel "stylesheet" :href "/dist/styles_css.css"}]]
         [:body
          [:div#app]
          [:script {:src "/assets/js/main.js"}]]]))))

;; Defines "/" and "/about" routes with their associated :get handlers.
;; The interceptors defined after the verb map (e.g., {:get home-page}
;; apply to / and its children (/about).
(def common-interceptors [(body-params/body-params) http/html-body])

;; Tabular routes
(def routes #{["/" :get (conj common-interceptors `home-page)]
              ["/about" :get (conj common-interceptors `about-page)]})

(def fix-charset
  {:name  ::fix-utf8
   :leave (fn [context]
            (update context :response
                    (fn [resp]
                      (ring-response/charset resp "utf-8"))))})

(defn base-service-config [system dev?]
  (-> {:env                     :prod
       ;; You can bring your own non-default interceptors. Make
       ;; sure you include routing and set it up right for
       ;; dev-mode. If you do, many other keys for configuring
       ;; default interceptors will be ignored.
       ;; ::http/interceptors []

       ;; do not block thread that starts web server
       ::http/join?             false

       ::http/routes            (if dev?
                                  #(route/expand-routes (deref #'routes))
                                  (route/expand-routes routes))

       ::http/resource-path "/public"

       ;; Uncomment next line to enable CORS support, add
       ;; string(s) specifying scheme, host and port for
       ;; allowed source(s):
       ;;
       ;; ""
       ;;
       ;;::http/allowed-origins [":port"]

       ;; Tune the Secure Headers
       ;; and specifically the Content Security Policy appropriate to your service/application
       ;; For more information, see: 
       ;;   See also: 
       ::http/secure-headers    {:content-security-policy-settings {:object-src "'none'"
                                                                    ;:script-src "'unsafe-inline' 'unsafe-eval' 'strict-dynamic' https: http:"
                                                                    ;:frame-ancestors "'none'"
                                                                    }}

       ;; Root for resource interceptor that is available by default.
       ;::http/resource-path     "/public"

       ;; Either :jetty, :immutant or :tomcat (see comments in project.clj)
       ;;  This can also be your own chain provider/server-fn -- 
       ::http/type              :jetty
       ;;::http/container-options {:context-configurator #(ws/add-ws-endpoints % ws-paths)}
       ;;::http/host "localhost"
       ::http/port              (:port env)

       ::http/container-options {:h2c? true
                                 :h2?  false
                                 ;:keystore "test/hp/keystore.jks"
                                 ;:key-password "password"
                                 ;:ssl-port 8443
                                 :ssl? false}
       #_#_::http/ext-mime-types {"htm"  "text/html;charset=utf-8"
                                  "html" "text/html;charset=utf-8"}}
      http/default-interceptors

      (update ::http/interceptors
              (fn [xs s] (into [s] xs))
              (interceptor/interceptor fix-charset))
      (update ::http/interceptors
              (fn [xs s] (into [s] xs))
              (interceptor/interceptor
                {:name  :add-system
                 :enter (fn [ctx]
                          (update
                            ctx
                            :request
                            assoc
                            ;; Add system, which has the db-pool
                            ;; Wrap in IDeref to prevent explosion when printed in an exception.
                            :system (reify IDeref
                                      (deref [_] system))))}))))

(defn add-dev-config [service-map]
  (-> service-map
      (merge {:env                   :dev
              ;; Routes can be a function that resolve routes,
              ;;  we can use this to set the routes to be reloadable
              ;; all origins are allowed in dev mode
              ::http/allowed-origins {:creds true :allowed-origins (constantly true)}
              ;; Content Security Policy (CSP) is mostly turned off in dev mode
              ::http/secure-headers  {:content-security-policy-settings {:object-src "'none'"}}})
      http/dev-interceptors))

(defmethod ig/init-key ::service
  [_ system]
  (let [dev?        (not= "prod" :mode env)
        service-map (cond-> (base-service-config system dev?)
                            dev? add-dev-config)]
    (log/info :msg "Starting" :dev? dev? :service ::service)

    {:system system
     :server (-> service-map
                 http/create-server
                 http/start)}))

(defmethod ig/halt-key! ::service [_ {:keys [system server]}]
  (when server
    (log/info :msg "Halting" :service ::service)
    (http/stop server)))

Så TLDR: For :routes key:

(if dev?
                                  #(route/expand-routes (deref #'routes))
                                  (route/expand-routes routes))

Ah jeg ser at du spørr om reitit, da blir det sikkert litt annerledes

godt mulig! men jeg ser jo at jeg helt har glemt å se i integrant.repl-namespacet Er sikkert noe der som kan hjelpe!

dette er en litt interessant “skyggeside” av Clojure du er inne på synes jeg. Når man er dreven og har ting i fingra så gjør man det alltid riktig og har ikke problemer med at ting ikke reloades riktig osv. Men det tar litt tid å komme dit, og man får det ikke “gratis” ut av boksen fra dag 1

Tja, når jeg starta å skrive kodebasen så hadde jeg jo et mer “koblet” oppsett hvor hver ny last av namespacet reloadet rutingen, så da funka det fint å iterere raskt og legge til/endre nye ruter. Men så begynte jeg med fancy overforbruk av integrant og endte opp i en situasjon hvor rutingen ikke enkelt kunne reloades sammen med namespacet.

I starten kunne jeg jo bare “varifisere” handleren som gikk inn i serveren, da funka det greit 😁