Following from goog.history example, if I do

(secretary/dispatch! "/777")

The dispatch doesn't adjust the url hash to #/777
Is there an option to have it adjust it?

For more context outside of the history example:

I am working with this bit of logic from Bruce Hauman's async todo's post:

(defn example2-loop [start-state]
  (let [ new-todo-click         (click-chan "a.new-todo" 
                                            :new-task)
         cancel-new-form-click  (click-chan "a.cancel-new-todo" 
                                            :cancel-new-form)
         input-chan             (async/merge [ new-todo-click 
                                               cancel-new-form-click])]
    (go
     (loop [state start-state]
       (render-templates state)
       (<! (get-next-message #{:new-task} input-chan))
       (render-templates (assoc state :mode :add-todo-form))
       (<! (get-next-message #{:cancel-new-form} input-chan))
       (recur (dissoc state :mode)))))

The program would ideally go through the following:

• User clicks on an item
  1. A message is put on a channel that blocks a go loop like the one above
  2. Dispatch is fired for a route (/test/route)
  3. The blocking statement shoots an goog.xhrio request
  4. When the xhr request is done the loop gets unblocked

This way if another item is clicked during the request:

• Url does not get adjusted
• No new xhr request is initiated

The road-block currently is that dispatch doesn't adjust the hash which ends up preventing the user from being able to deep link.

The fix I tried was to use a elements with href="#/test/route" but that creates the problem where even if the loop is blocked, the user can still go to another url hash by clicking more links. Which can create a discrepancy between the data that eventually loads and what the hash is actually showing.

Currently my thinking is that this would be solved by having dispatch adjust the url hash to reflect where it has been dispatched to. Is there a better solution to this?

Hope that makes sense and thanks for reading through it!

Given this route definition:

(defroute exchange-link "/exchange" [z]
  (println "route params" z))

and this invokation:

(sec/dispatch! "/exchange?a=b")

I'm getting:

route params nil

instead of

route params {:query-params ... }

(defroute exchange-link "/exchange" {:keys [query-params]}
  (println "route params" query-params))

gives the same result.

Using [org.clojure/clojurescript "0.0-2280"] the following works in [secretary "1.1.1"] but not in [secretary "1.2.0"]

(def history (Html5History.))
(.setUseFragment history false)

(defroute "test" [] 
  (log "TEST")
  (set-html! (js/document.getElementById "main-container") "TEST"))

(events/listen history EventType.NAVIGATE
  (fn [e] (secretary/dispatch! (.-token e))))

(.setEnabled history true)

I'm using goog.History as you suggested in the readme. I've been using (set! (.-href window.location) url) to redirect user (like ) to another page. But it always flashes the homepage first then go there. I also tried (.setToken (History.) "/add") but that only changes the address bar and not actually load the new page so it gives a blank page.

Is there a correct way of redirecting the browser please?

Hi,
what is the best way to check if a route is handled in version 2?
In the previous version there was a function called locate-route that was very helpful.
Thanks

I'm trying to store named routes in a map and use as part of a look-up, such as...

(navigate! :submit-page)

I have two routes (/ and /submit for now) and I'm currently trying:

(defroute sec (str route) []
      (log/info "Routing to" route)
      (launch-route! route))
    (swap! routes assoc-in [(route-to-keyword route)] sec)

This produces the following atom:

#<Atom: {:r #<function venue$core$add_view_BANG__$_sec(){
var argseq__17077__auto__ = ((((0) < arguments.length))?(new cljs.core.IndexedSeq(Array.prototype.slice.call(arguments,(0)),(0))):null);
return venue.core.sec.cljs$core$IFn$_invoke$arity$variadic(argseq__17077__auto__);
}>, :r-submit #<function venue$core$add_view_BANG__$_sec(){
var argseq__17077__auto__ = ((((0) < arguments.length))?(new cljs.core.IndexedSeq(Array.prototype.slice.call(arguments,(0)),(0))):null);
return venue.core.sec.cljs$core$IFn$_invoke$arity$variadic(argseq__17077__auto__);
}>}>

You'll notice that both values are identical. And sure enough...

venue.core> ((:r- @routes))
"#/submit" ;; we were expecting "#/"

Fair enough, the symbols are called the same thing. So I've also tried using a macro but the result was the same (gensym returns the same symbol venue$core$add_view_BANG__$_G__49633? What's going on here?)

(defmacro defroute!
  [route routes funcn]
  (let [sec-obj (gensym)]
    `(do
       (secretary/defroute ~sec-obj ~route []
         (~funcn ~route))
       (swap! ~routes assoc-in [(route-to-keyword ~route)] ~sec-obj))))

#<Atom: {:r- #<function venue$core$add_view_BANG__$_G__49633(){
var argseq__17077__auto__ = ((((0) < arguments.length))?(new cljs.core.IndexedSeq(Array.prototype.slice.call(arguments,(0)),(0))):null);
return venue.core.G__49633.cljs$core$IFn$_invoke$arity$variadic(argseq__17077__auto__);
}>, :r-submit #<function venue$core$add_view_BANG__$_G__49633(){
var argseq__17077__auto__ = ((((0) < arguments.length))?(new cljs.core.IndexedSeq(Array.prototype.slice.call(arguments,(0)),(0))):null);
return venue.core.G__49633.cljs$core$IFn$_invoke$arity$variadic(argseq__17077__auto__);
}>}>

Is there something about defroute that makes this impossible or is there actually a way to do this? Is it ClojureScript scuppering my plans? Thanks for your help

Hello,

com.cemerick/clojurescript.test is deprecated. Is it worth while converting to doo and CLJS's built-in clojurescript.test suite?

In addition to being linked to an actively maintained project it would have some additional benefits like eliminating a SNAPSHOT dependency.

Is this something you'd be willing to entertain as a PR?

Kind regards,
Nathan

I'd like to be able to specify a route similar to this:

(defroute my-path "/design/:filter-name/:id" [filter-name id]
  ; do something
  )

(my-path {:id 5}) ; currently yields "/design/:filter-name/5", but I'd like to be able to specify a default for filter-name

And have the generated named path be able to specify default values to the parameters, rather than a keyword being used. I'm not really sure how this could be accomplished.

This is pretty closely related to having trailing slashes being elided, too... these two use-cases seem to be common enough that a solution would be really great to have in secretary itself, perhaps.

This is probably PEBCAK.
I have the following tiny application using secretary and reagent. Calls to secretary/dispatch! like the one at the bottom of the file update the application as expected. Clicking on the links, however, does not result in a call to dispatch.
Any pointers you can provide will be appreciated. Thanks in advance!

(ns askit-client.main
    (:require [reagent.core :as reagent]
              [secretary.core :as secretary :refer-macros [defroute]]))

(enable-console-print!)


;; Define reagent components
(defn home []
    [:div [:h1 "Welcome, friend!"]
        [:div [:a {:href "#/about"} "about us"]]])
(defn about []
    [:div "Now you know all about us!"
        [:div [:a {:href "#/"} "go home"]]])
(defn current-page [] [(@app-state :current-page)])




;; Set up application state
(def app-state (reagent/atom {}))

(defn put! [k v] (swap! app-state assoc k v))

(put! :current-page home)



;; Define secretary routes
(secretary/set-config! :prefix "#")
(defroute "/" []
    (println "time to go home")
    (put! :current-page home))
(defroute "/about" []
    (println "time to go about")
    (put! :current-page about))



(println "Let's mount this thing and go home!")
(reagent/render-component [current-page] (.getElementById js/document "app"))

(secretary/dispatch! "/about")

From the secretary history example:

;; Quick and dirty history configuration.
(let [h (History.)]
  (goog.events/listen h EventType.NAVIGATE #(secretary/dispatch! (.-token %)))
  (doto h
    (.setEnabled true)))

In my experience, the first event from goog.History.Event has a target of "" by default. I think for many applications, it is useful to handle this differently. Maybe a few quick changes to the example would be in order?

Here is some sample code that I use:

(let [h (History.)
      f (fn [he] ;; goog.History.Event
          (.log js/console "navigate %o" (clj->js he))
          (let [token (.-token he)]
            (if (seq token)
              (secretary/dispatch! token)))))]
  (events/listen h EventType/NAVIGATE f)
  (doto h (.setEnabled true)))

Another way might be to test isNavigation. From history.Event:

isNavigation : boolean
True if the event was triggered by a browser action, such as forward or back, clicking on a link, editing the URL, or calling window.history.(go|back|forward). False if the token has been changed by a setToken or replaceToken call.

Add more documentation/examples for real-world usage.

Allow defroute to optionally be passed a symbol which will both create the route and define a function. This function can then be used to create routes.

(defroute user-path "/users/:id" {:as params}
  ...)

(user-path {:id 1}) ;; => "/users/1"

I'm trying to use secretary in conjunction with om and it works fine using the release cljsbuild settings, however the development settings don't work. I'm not sure if it's the source map that's messing it up or the js include in the index.html.

https://github.com/swannodette/om#using-it

Using the following dev build settings I get an error that defroute is undefined:

:cljsbuild {
  :builds [{:id "dev"
            :source-paths ["src"]
            :compiler {
              :output-to "main.js"
              :output-dir "out"
              :optimizations :none
              :source-map true}}]}

    <script src="main.js" type="text/javascript"></script>
    <script type="text/javascript">goog.require("main.core");</script>

It's probably a long shot but is there a way to use secretary without using encoded URIs. Like being able to dispatch to utf-8 without encoding first and named routes returning utf-8 URIs.

I'm not sure if there actually are any browsers that require encoded URIs but man are they ugly and awkward as permalinks.

I'm actually wondering if this was intentional or not because 1.2.1 only had secretary/*

upgrading to it broke my app because my app serves the index.html dynamically from a template but I believe the ring.middleware.resource.wrap-resource is picking up the index.html from 1.2.2 instead of my handler.

I could probably work around this, but I suspect, 1.2.2 was probably not supposed to be packaged with all the public/out/* stuff

Would be nice to have a reference example that does not use the # prefix.

This will require some extra plumbing but has obvious uses cases. For example

(defroute not-found "*" [] ...)

If we define the following route:

(defroute "/foo" []
  (.log js/console "matched /foo"))

it will match calls to "/foo" but not "/foo/" (notice the trailing slash). This is something that is also reported in weavejester/compojure#68

I was able to find a workaround by defining my route using a regex, like the following:

(defroute #"/foo(/)*" []
  (.log js/console "matched /foo"))

but I don't quite like this solution.

Is this an actual issue or is secretary supposed to behave like this by design?

I must be missing a fundamental understanding of how defroute works. I have this:

(.log js/console "running") 

(defroute "*" {:as r}
  (.log js/console "route: " r))

When the app loads, the "running" prints to the screen. I would expect that this route would also run regardless of which URI I visited on the server which is loading this page. But there is never any other logging that shows.

I also tried with more specific routes with wildcards but the same behavior, when I visit the URL, while the JS file itself clearly loads and runs, the defroutes aren't triggering in their bodies based on the URL they are supposed to match.

Sorry if I've missed this in the docs somewhere, however:

I've got things setup nicely with my routes and reagent for rendering. The secretary/dispatch! works great for navigating around, and my HTML5 navigation on the server is correctly loading the application index and providing the correct paths to secretary on deep links when the page loads.

My question is, how can I update the location in the URL bar on dispatch? Is this something I should be looking into in the Google Closure docs or have I misconfigured secretary somehow?

Once you specify defroute default-route, any defroutes after it get ignored.

I thought default-route was special for this reason that it would not override things like this.

Not sure if this is a secretary bug or me misunderstanding how the browser is supposed to work.

I have 2 routes:

(defroute "/a" {:as m}  (.log js/console m) (show-page-a))
(defroute "/b" {:as m}  (show-page-b))

If I load a route like /a?foo=bar I see those params logged as expected, if I follow a link to /b then press back button, I get an empty map logged even though the url is still /a?foo=bar.

I'm using accountant to call dispatch! when following links, so there isn't a full page reload at that point.

Allow routes to be dispatched from (and optionally defined to?) different collections. This'll make things like testing and optional routes easier to work with.

E.g.:

(secretary/dispatch! "/users/gf3")
;; To ↓ 
(secretary/dispatch! some-defed-routes "/users/gf3")

Thanks for the suggestion, @sgrove.

Starting 2371 the proper way to refer a macro is:

(ns app.routes
  (:require [secretary.core :as secretary :refer-macros [defroute]]))

The documentation should probably mention this change.

org.clojure/clojurescript dependency leaks into projects including secretary. This is a problem when this project is also a regular clojure project as org.clojure/clojurescript ends up packaged in final uberjar.

A simple workaround is to use :exclusions [org.clojure/clojurescript].
Probably the proper way to handle this is to define org.clojure/clojurescript dependency in the dev profile.

I am getting a WARNING: No such namespace: goog.history.EventType at line 59 src/cljs/core.cljs when I just copy and paste the basic history example.

Is it something on my end?

I think the following dispatch should go into the "catch all" route, but it is going to the "users" route:

(defroute "/users/:id" [id]
  (println "User" id))

(defroute "*" []
  (println "catch all"))

(secretary/dispatch! "") ; => prints "User nil"

I suppose the use-case here is to catch the default home route, but I don't see the ability here.

There used to be any-matches? which is IMO necessary in the secretary API.
locate-route is a private function. Maybe expose it, or alias it with a name that indicates it can be used as a predicate. Thank you.

(defn- locate-route [route]
  (some
   (fn [[compiled-route action]]
     (when-let [params (route-matches compiled-route route)]
       [action (route-matches compiled-route route)]))
   @*routes*))

Hi

I have an app which uses Secretary to define the routes for the system.

so routes.cljs has the route definitions.

routes.cljs references some controller namespaces in order to route people to the right controller when things change.

Additionally, controllers sometimes need to send people places.

routes -> controller -> routes

This is a circular dependency.
I believe there's no way around it since in my case the things which are accepting being routed-to also want to route people to other places.

In my earlier home-grown efforts I had split paths and routes into two files so that I could avoid this.

e.g.

routes -> paths  (to generate the link btwn URL paths and behaviors)
routes -> controllers (to shuttle control to a controller)
controllers -> paths (to generate paths to things)

Is there something like this in Secretary / has someone come up with any solutions other than "reorganize your code"?

I looked and there seemed to only be the "mother-macro" defroute, and I wasn't clear on how to split that apart.

This seems like such a common issue that I hope there is something simple...
like:

paths.cljs
(defpath article  "/article/:id")
;; Returns a (defn article-path which just generates a "string")
;; This can perform the machinations to generate URLs correctly

routes.cljs
(defroute (article-path :id)
   (do-whatever id))
;; So here, the article-path is handing back a stirng with the first parameter set to :id
;; e.g. /articles/:id 

Something along those lines.
Thanks!

To demonstrate the issue:

(defroute good "/:a:b/:c" [])
(good {:a 1 :b 2 :c 3}) => "/12/3"

(defroute bad "/:a-:b/:c" [])
(bad {:a 1 :b 2 :c 3}) => "/:a-2/3"

Is there any way to render "bad" as "/1-2/3"?

What is the right way to abandon any/every route definition? I'm using secretary in component which I want to be able to start/stop clean.

The readme mentions that "If the browser you're targeting does not support HTML5 history you can call (secretary/set-config! :prefix "#") to prefix generated URIs with a "#"."

It seems that should a call to set-config! be omitted, the :prefix will be set to an empty string. That leads me to believe that generated routes would have no kind of prefix in the url -- yet all of mine do by default.

Is the # prefix supposed to always be present by default, or is there a way to disable it?

Can i have a link that goes to "/about" instead of "/#about"?
I have all other elements of an isomorphic app up and running except this part.

A la context du compjure.

Collection values are encoded into query params with brackets attached as a suffix. When parsing back the url query string, the keys are not decoded. As brackets in query keys tend to be percent encoded in several tools, parser should decode them.

Example of such query, github percent encodes brackets in the href of the following link automatically:
http://example.com/search?terms[]=foo&terms[]=bar

In https://github.com/borkdude/sliders-cljs I have tried to incorporate [secretary "1.0.2"] and the example given on the README page of secretary, combined with Om.

Problem: when I browse directly to sliders-cljs/resources/public/index.html#/users I should see USERS!, but I'm seeing OMG! YOU'RE HOME!. See this screenshot:

When I change the uri to /777 I see the correct screen.
When I change the uri to /users I also see the correct screen. Upon refresh I'm seeing the OMG! YOU'RE HOME! screen again, with the same uri /users.

For example, when user clicks <a href="#/users/jim">Jim</a>, it will trigger
(defroute user-path "/users/:id" [id] ...). However, the event is not triggered when I directly type in a new window index.html#/users/jim.

In Emberjs, the state is associated with each URL, so bookmarks in the browser can reference the exact state which the user want to save.

First time a page loads there is no dispatch. For example my SPA has a certain component to display if they are on /login, the app determines that by a dispatch on secretary navigate. When you navigate directly to /login secretary fails to trigger the dispatch.

What's a recommended way to build a login wall to a Secretary routed app? Currently I'm doing this up top on my routes namespace.

(defn enforce-login []
  "Check authentication of user then redirect to login page if not"
  (when-not (re-seq #"/#/login$" (.-href js/window.location)) ;; not at login page
    (if-let [token (c/get-token)]
      (go-authenticate token)
      (.replace window.location "/#/login"))))

It sort of work but user can still jump into any route if they know the URL. I'm thinking I could wrap each route with a authorisation func first?

(defroute "/foo" [] (auth? (run-foo)))

That's basically a middleware.

Is there middleware for Secretary? If not, could you point me the right way to making one please?

I couldn't figure out how to do this properly. Right now http://example.com/ is blank because all my routes are set by secretary. Users need to use http://example.com/#/ for the app to load. Is there a way to set a root route? I'm thinking of redirecting / to /#/ but I don't know how to do that aside from hardcoding it in the index.html which would break things. Any suggestion please?

I get the following warning while compiling my application:

WARNING: Referred var secretary.core/defroute does not exist at line 1 src-cljs/myproject/main.cljs

And running the app in browser yields:

Uncaught TypeError: Cannot read property 'call' of undefined

from a line:

(defroute "/" [] (render-view dashboard-view))

The namespace declaration is:

(ns myproject.main
  (:require [secretary.core :as secretary :include-macros true :refer [defroute]]))

And project configuration:

(defproject myproject "0.1.0-SNAPSHOT"
  :dependencies [[org.clojure/clojure "1.6.0"]
                 [org.clojure/clojurescript "0.0-2371"]
                 [om "0.8.0-alpha1"]
                 [secretary "1.2.1"]
                 [prismatic/om-tools "0.3.6"]
                 [cljs-ajax "0.2.6"]]
  :plugins [
            [lein-cljsbuild "1.0.3"]]
  :cljsbuild {:builds [{:source-paths ["src-cljs"]
                        :compiler {:output-to "resources/public/js/app.js"
                                   :output-dir "resources/public/js/out"
                                   :source-map true
                                   :optimizations :none
                                   :pretty-print true}}]})

Using Java8 (update25) on OSX.

This doesn't always come up but occasionally it's necessary.

(secretary/encode-query-params {:foo [1 2 3]})
;; => "foo[]=1&foo[]=2&foo[]3"
(secretary/decode-query-params "foo[]=1&foo[]=2&foo[]3")
;; => {:foo ["1" "2" "3"]}
(secretary/encode-query-params {:foo {:a 1 :b 2}})
;; => "foo[a]=1&foo[b]=2"
(secretary/decode-query-params "foo[a]=1&foo[b]=2")
;; => {:foo {:a "1" :b "2"}}

Expect a patch for this today.

When invalid URL is entered by the user, such as:

http://host/some/path?param=val%%ue

encodeURIComponent and/or decodeURIComponent throw an unhandled exception and Secretary stops working. It would be nice if Secretary would be able to let app know such thing happened (it might be a bug in the app itself, invalid route, or something else) so that an app could do whatever it thinks makes sense.

So something like that maybe (this is just a out of the top of my head proposal):

(defroute :invalid-url [] ...)

Is such a thing possible with Secretary out of the box?

In our project we needed to handle it recently and so far I worked around it with this JS snippet that redirects to the "/error-path" with a proper error message. This is far from being ideal though.

(function() {
  var wrapWithCatch = function(fnName) {
    var orig = window[fnName];
    window[fnName] = function() {
      try {
        return orig.apply(null, arguments);
      } catch (e) {
        console.error("Error in " + fnName + ", redirecting.", e);
        window.location.hash = "/error-path";
      }
    };
  };

  wrapWithCatch("decodeURIComponent");
  wrapWithCatch("encodeURIComponent");
})();

I'm using Foundation 5 for my CSS template and their javascript component asks for calling their JS function at the end of each page. Foundation is not seeing the new DOMs on routing so they aren't working. Is it possible to run a function after each page dispatch in secretary?

I just put together a minimal example recreating something I have been experienced. I was wondering if it were possible for clicking on an href not to retrigger the router. It seems that something in the secretary library is listening to the click event before my click handler has the chance to prevent it from doing so. Is it possible to keep the route's handler from being fired?

(ns minimal-example.core
    (:require [reagent.core :as reagent :refer [atom]]
              [reagent.session :as session]
              [secretary.core :as secretary :include-macros true]
              [accountant.core :as accountant]))

;; -------------------------
;; Views

(defn first-tab []
  [:div "FIRST TAB!"])

(defn second-tab []
  [:div "SECOND TAB!"])

(def selected-tab (atom nil))

(def tabs [{:key "one"
            :name "one"
            :cmp first-tab}
           {:key "two"
            :name "two"
            :cmp second-tab}])

(defn home-page []
  (reagent/create-class
   {:component-did-mount (fn []
                           (reset! selected-tab (-> tabs
                                                    first
                                                    :key)))
    :reagent-render (fn []
                      [:div
                       [:ul
                        (doall
                         (map (fn [item]
                                [:li
                                 [:a {:href "#"
                                      :on-click (fn [e]
                                                (reset! selected-tab (:key item))
                                                (.preventDefault e)
                                                (.preventPropogation e)
                                                false)}
                                  (:name item)]]
                                ) tabs))]
                       (doall
                        (map (fn [{:keys [key cmp]}]
                              (when (= key @selected-tab)
                                [cmp]))
                             tabs))])}))

(defn current-page []
  [:div [(session/get :current-page)]])

(secretary/defroute "/" []
  (session/put! :current-page #'home-page))

(defn mount-root []
  (reagent/render [current-page] (.getElementById js/document "app")))

(defn init! []
  (accountant/configure-navigation!
    {:nav-handler
     (fn [path]
       (secretary/dispatch! path))
     :path-exists?
     (fn [path]
       (secretary/locate-route path))})
  (accountant/dispatch-current!)
  (mount-root))

...continues discussion from IRC.

I propose to add a mechanism for performing pre-/during-/post- actions, after dispatch has happened (that is, wrapping the form in defroute).

Here is a set of proposed protocols and some usage patterns:

(defprotocol IPreRoutingAction
   (pre-routing-action [this] ...))

(defprotocol IRoutingAction
   (routing-action [this] ...))

(defprotocol IPostRoutingAction
   (routing-action [this] ...))

By default, you would continue to call defroute as now:

(defroute "/myroute/:id" [id]
  ;; ...do stuff...)

But, you could then also do something like this (mimicking Om usage patterns):

(defroute "/myroute/:id" [id]
  (reify
    IPreRoutingAction
    (pre-routing-action [this]
     ;; ...)
    IRoutingAction
    (routing-action [this]
     ;; ... the stuff from before ...)))

A more concrete use-case (and why I was proposing it in the first place):

(deftype Page []
  IPreRoutingAction
  (pre-routing-action [this page-args]
    (load-page! page-args))
  IRoutingAction
  (routing-action [this page-args]
    (load-header! (:name page-args)))

(defroute "/myroute/:id" [id]
  (Page. id {:name "foo"}))

This would eliminate a lot of boilerplate and satisfy the needs of many developers building complex one-page apps in CLJS (as we are).

Also proposed by noprompt: IWillNavigate/INavigate/IDidNavigate protocols. Should pre-dispatch protocols be allowed in arguments to defroute? Etc.

Okay, this is just the first proposal--let me know what you think.

When dispatch method receives a URL like

page-visits/path=%2F60645%2Fzon-en-zee-strandhotel-westende%2F/day=2015-08-19%7C2015-08-19

;; this is the route
(defroute "/:module/*" {:as params}
  (move-to params))

the route is called with the following parameters

{:module "page-visits" 
  :* "path=/60645/zon-en-zee-strandhotel-westende//day=2015-08-19|2015-08-19"

Is this an expected behaviour ? Could it be because of this https://github.com/gf3/secretary/blob/fc8b53e77604e87db82a68aec0e4e98fe3ba6fb8/src/secretary/core.cljs#L250

Cheers,
Bahadir

Hiya there,

First of all, thank you very much for that piece of free software :-) I've been using happily for a long time and it works well expect for this edge case which has been rather painful for me. To the best of my knowledge there is no issue about this so I fill this one just to reference this behaviour.

According to Wikipedia (and explained in a very circumlocutory way on https://url.spec.whatwg.org/) the syntax of a URL is :

scheme:[//[user:password@]host[:port]][/]path[?query][#fragment]

However, when secretary is used without html5 routing the in-app route is stored in the fragment and then the query part is added. Reasons for this are obvious (legibility) but resulting URL respect no longer the syntax. Instead, they use this custom syntax:

scheme:[//[user:password@]host[:port]][/]path[#fragment][?query]

Using this custom syntax will cause Secretary and Standard libraries to firmly disagree on some painful edge cases, e.g. :

https://www.example.com/path/of/app#path/inside/app?query=params&as=defined&by=secretary

• fragment: "path/inside/app?query=params&as=defined&by=secretary" for standard libraries but should be "path/inside/app" according to Secretary
• query: "" but should be "query=params&as=defined&by=secretary" according to Secretary

Of course, a very naive regex will get us data we need:

(def hash-according-to-secretary-syntax
  (comp second (partial re-find #"\#([^?]*)"))

I just wonder if you could add tiny functions somewhere in a utility namespace to allow Secretary's users to access fragment and query as meant by the custom syntax used. If you agree with this but don't have much time to spare on this detail, just give me general directions about where / how put new code and I'll be happy to do that.