luciano/reitit
1
0
Fork 0
mirror of https://github.com/metosin/reitit.git synced 2025-12-18 08:51:12 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Merge pull request #25 from metosin/DuplicateRoutes

Browse source 
Handle conflicting routes, custom & mixed-router
This commit is contained in:
Tommi Reiman 2017-08-22 16:48:20 +03:00 committed by GitHub
commit 4cd5dfee40
5 changed files with 201 additions and 50 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
README.md
View file

@ -393,13 +393,15 @@ Authorized access to guarded route:
Routers can be configured via options. Options allow things like [`clojure.spec`](https://clojure.org/about/spec) validation for meta-data and fast, compiled handlers. The following options are available for the `reitit.core/router`:
| key | description |
| -----------|-------------|
| -------------|-------------|
| `:path` | Base-path for routes (default `""`)
| `:routes` | Initial resolved routes (default `[]`)
| `:meta` | Initial expanded route-meta vector (default `[]`)
| `:expand` | Function of `arg opts => meta` to expand route arg to route meta-data (default `reitit.core/expand`)
| `:coerce` | Function of `route opts => route` to coerce resolved route, can throw or return `nil`
| `:compile` | Function of `route opts => handler` to compile a route handler
| `:conflicts` | Function of `{route #{route}} => side-effect` to handle conflicting routes (default `reitit.core/throw-on-conflicts!`)
| `:router` | Function of `routes opts => router` to override the actual router implementation
## Special thanks

30
perf-test/clj/reitit/opensensors_routing_test.clj
View file

@ -120,7 +120,7 @@
["/v1/orgs/:org-id/errors" {:handler handler, :name :test/route17}]
["/v1/public/orgs/:org-id" {:handler handler, :name :test/route18}]
["/v1/orgs/:org-id/invitations" {:handler handler, :name :test/route19}]
["/v2/public/messages/dataset/bulk" {:handler handler, :name :test/route20}]
#_["/v2/public/messages/dataset/bulk" {:handler handler, :name :test/route20}]
#_["/v1/users/:user-id/devices/bulk" {:handler handler, :name :test/route21}]
["/v1/users/:user-id/device-errors" {:handler handler, :name :test/route22}]
["/v2/login" {:handler handler, :name :test/route23}]
@ -202,13 +202,13 @@
"whoami" :test/route41
"login" :test/route51}
"v2/" {"whoami" :test/route1
["users/" :user-id "/"] {"datasets" :test/route2
"devices" :test/route25
"topics" {"/bulk" :test/route29
["users/" :user-id] {"/datasets" :test/route2
"/devices" :test/route25
"/topics" {"/bulk" :test/route29
"" :test/route45}}
"public/" {["projects/" :project-id] {"/datasets" :test/route3
"" :test/route27}
"messages/dataset/bulk" :test/route20
#_#_"messages/dataset/bulk" :test/route20
["datasets/" :dataset-id] :test/route28
["messages/dataset/" :dataset-id] :test/route53}
["datasets/" :dataset-id] :test/route11
@ -264,11 +264,11 @@
"/v2/" {"whoami" [:test/route1]
["users/" user-id] {"/datasets" [:test/route2 user-id]
"/devices" [:test/route25 user-id]
"topics/" {"bulk" [:test/route29 user-id]
"/topics" {"/bulk" [:test/route29 user-id]
"" [:test/route45 user-id]}}
"public/" {["projects/" project-id] {"/datasets" [:test/route3 project-id]
"" [:test/route27 project-id]}
"messages/dataset/bulk" [:test/route20]
#_#_"messages/dataset/bulk" [:test/route20]
["datasets/" dataset-id] [:test/route28 dataset-id]
["messages/dataset/" dataset-id] [:test/route53 dataset-id]}
["datasets/" dataset-id] [:test/route11 dataset-id]
@ -344,7 +344,7 @@
(context "/projects/:project-id" []
(ANY "/datasets" [] {:name :test/route3} handler)
(ANY "/" [] {:name :test/route27} handler))
(ANY "/messages/dataset/bulk" [] {:name :test/route20} handler)
#_(ANY "/messages/dataset/bulk" [] {:name :test/route20} handler)
(ANY "/datasets/:dataset-id" [] {:name :test/route28} handler)
(ANY "/messages/dataset/:dataset-id" [] {:name :test/route53} handler))
(ANY "/datasets/:dataset-id" [] {:name :test/route11} handler)
@ -376,7 +376,7 @@
["/v1/orgs/:org-id/errors" :get handler :route-name :test/route17]
["/v1/public/orgs/:org-id" :get handler :route-name :test/route18]
["/v1/orgs/:org-id/invitations" :get handler :route-name :test/route19]
["/v2/public/messages/dataset/bulk" :get handler :route-name :test/route20]
#_["/v2/public/messages/dataset/bulk" :get handler :route-name :test/route20]
#_["/v1/users/:user-id/devices/bulk" :get handler :route-name :test/route21]
["/v1/users/:user-id/device-errors" :get handler :route-name :test/route22]
["/v2/login" :get handler :route-name :test/route23]
@ -493,12 +493,12 @@
compojure-api-f #(opensensors-compojure-api-routes {:uri % :request-method :get})
pedestal-f #(pedestal/find-route opensensors-pedestal-routes {:path-info % :request-method :get})]
(bench! routes true "reitit" reitit-f) ;; 2538ns 10%
(bench! routes true "pedestal" pedestal-f) ;; 2737ns 11%
(bench! routes true "reitit-ring" reitit-ring-f) ;; 2845ns 11%
(bench! routes true "compojure-api" compojure-api-f) ;; 10215ns 41%
(bench! routes true "bidi" bidi-f) ;; 19298ns 77%
(bench! routes true "ataraxy" ataraxy-f) ;; 24950ns 100%
(bench! routes true "reitit" reitit-f) ;; 2538ns -> 2028ns
(bench! routes true "reitit-ring" reitit-ring-f) ;; 2845ns -> 2299ns
(bench! routes true "pedestal" pedestal-f) ;; 2737ns
(bench! routes true "compojure-api" compojure-api-f) ;; 9823ns
(bench! routes true "bidi" bidi-f) ;; 16716ns
(bench! routes true "ataraxy" ataraxy-f) ;; 24467ns
))

99
src/reitit/core.cljc
View file

@ -1,5 +1,6 @@
(ns reitit.core
(:require [meta-merge.core :refer [meta-merge]]
[clojure.string :as str]
[reitit.impl :as impl #?@(:cljs [:refer [Route]])])
#?(:clj
(:import (reitit.impl Route))))
@ -60,16 +61,38 @@
(cond->> (->> (walk data opts) (map-meta merge-meta))
coerce (into [] (keep #(coerce % opts)))))
;; This whole function might be more efficient and easier to understand with transducers.
(defn conflicting-routes [routes]
(some->>
(loop [[r & rest] routes, acc {}]
(if (seq rest)
(let [conflicting (set (keep #(if (impl/conflicting-routes? r %) %) rest))]
(recur rest (update acc r (fnil (comp set concat) #{}) conflicting)))
acc))
(filter (comp seq second))
(seq)
(into {})))
(defn throw-on-conflicts! [conflicts]
(throw
(ex-info
(apply str "router contains conflicting routes:\n\n"
(mapv
(fn [[[path] vals]]
(str " " path "\n-> " (str/join "\n-> " (mapv first vals)) "\n\n"))
conflicts))
{:conflicts conflicts})))
(defn name-lookup [[_ {:keys [name]}] opts]
(if name #{name}))
(defn find-names [routes opts]
(into [] (keep #(-> % second :name) routes)))
(into [] (keep #(-> % second :name)) routes))
(defn compile-route [[p m :as route] {:keys [compile] :as opts}]
[p m (if compile (compile route opts))])
(defprotocol Routing
(defprotocol Router
(router-type [this])
(routes [this])
(options [this])
@ -97,10 +120,11 @@
{:lookup name-lookup
:expand expand
:coerce (fn [route _] route)
:compile (fn [[_ {:keys [handler]}] _] handler)})
:compile (fn [[_ {:keys [handler]}] _] handler)
:conflicts throw-on-conflicts!})
(defn linear-router
"Creates a [[LinearRouter]] from resolved routes and optional
"Creates a LinearRouter from resolved routes and optional
expanded options. See [[router]] for available options"
([routes]
(linear-router routes {}))
@ -118,7 +142,7 @@
[[] {}] compiled)
lookup (impl/fast-map lookup)]
(reify
Routing
Router
(router-type [_]
:linear-router)
(routes [_]
@ -146,11 +170,11 @@
([routes]
(lookup-router routes {}))
([routes opts]
(when-let [route (some impl/contains-wilds? (map first routes))]
(when-let [wilds (seq (filter impl/wild-route? routes))]
(throw
(ex-info
(str "can't create LookupRouter with wildcard routes: " route)
{:route route
(str "can't create LookupRouter with wildcard routes: " wilds)
{:wilds wilds
:routes routes})))
(let [compiled (map #(compile-route % opts) routes)
names (find-names routes opts)
@ -162,7 +186,7 @@
lookup)]) [{} {}] compiled)
data (impl/fast-map data)
lookup (impl/fast-map lookup)]
(reify Routing
(reify Router
(router-type [_]
:lookup-router)
(routes [_]
@ -180,23 +204,68 @@
(if-let [match (impl/fast-get lookup name)]
(match params)))))))
(defn mixed-router
"Creates two routers: [[lookup-router]] for static routes and
[[linear-router]] for wildcard routes. All routes should be
non-conflicting. Takes resolved routes and optional
expanded options. See [[router]] for options."
([routes]
(mixed-router routes {}))
([routes opts]
(let [{linear true, lookup false} (group-by impl/wild-route? routes)
linear-router (linear-router linear opts)
lookup-router (lookup-router lookup opts)
names (find-names routes opts)]
(reify Router
(router-type [_]
:mixed-router)
(routes [_]
routes)
(options [_]
opts)
(route-names [_]
names)
(match-by-path [_ path]
(or (match-by-path lookup-router path)
(match-by-path linear-router path)))
(match-by-name [_ name]
(or (match-by-name lookup-router name)
(match-by-name linear-router name)))
(match-by-name [_ name params]
(or (match-by-name lookup-router name params)
(match-by-name linear-router name params)))))))
(defn router
"Create a [[Router]] from raw route data and optionally an options map.
If routes contain wildcards, a [[LinearRouter]] is used, otherwise a
[[LookupRouter]]. The following options are available:
| key | description |
| -----------|-------------|
| -------------|-------------|
| `:path` | Base-path for routes (default `\"\"`)
| `:routes` | Initial resolved routes (default `[]`)
| `:meta` | Initial expanded route-meta vector (default `[]`)
| `:expand` | Function of `arg opts => meta` to expand route arg to route meta-data (default `reitit.core/expand`)
| `:coerce` | Function of `route opts => route` to coerce resolved route, can throw or return `nil`
| `:compile` | Function of `route opts => handler` to compile a route handler"
| `:compile` | Function of `route opts => handler` to compile a route handler
| `:conflicts` | Function of `{route #{route}} => side-effect` to handle conflicting routes (default `reitit.core/throw-on-conflicts!`)
| `:router` | Function of `routes opts => router` to override the actual router implementation"
([data]
(router data {}))
([data opts]
(let [opts (meta-merge default-router-options opts)
routes (resolve-routes data opts)]
((if (some impl/contains-wilds? (map first routes))
linear-router lookup-router) routes opts))))
(let [{:keys [router] :as opts} (meta-merge default-router-options opts)
routes (resolve-routes data opts)
conflicting (conflicting-routes routes)
wilds? (some impl/wild-route? routes)
all-wilds? (every? impl/wild-route? routes)
router (cond
router router
(not wilds?) lookup-router
all-wilds? linear-router
(not conflicting) mixed-router
:else linear-router)]
(when-let [conflicts (:conflicts opts)]
(when conflicting (conflicts conflicting)))
(router routes opts))))

22
src/reitit/impl.cljc
View file

@ -121,6 +121,28 @@
:matcher #(if (= path %) {})
:handler handler})))
(defn segments [path]
(let [ss (-> (str/split path #"/") rest vec)]
(if (str/ends-with? path "/")
(conj ss "") ss)))
(defn- catch-all? [segment]
(= \* (first segment)))
(defn wild-route? [[path]]
(contains-wilds? path))
(defn conflicting-routes? [[p1 :as route1] [p2 :as route2]]
(loop [[s1 & ss1] (segments p1)
[s2 & ss2] (segments p2)]
(cond
(= s1 s2 nil) true
(or (nil? s1) (nil? s2)) false
(or (catch-all? s1) (catch-all? s2)) true
(or (wild? s1) (wild? s2)) (recur ss1 ss2)
(not= s1 s2) false
:else (recur ss1 ss2))))
(defn path-for [^Route route params]
(if-let [required (:params route)]
(if (every? #(contains? params %) required)

68
test/cljc/reitit/core_test.cljc
View file

@ -1,13 +1,13 @@
(ns reitit.core-test
(:require [clojure.test :refer [deftest testing is]]
[reitit.core :as reitit #?@(:cljs [:refer [Match]])])
(:require [clojure.test :refer [deftest testing is are]]
[reitit.core :as reitit #?@(:cljs [:refer [Match Router]])])
#?(:clj
(:import (reitit.core Match)
(:import (reitit.core Match Router)
(clojure.lang ExceptionInfo))))
(deftest reitit-test
(testing "linear router"
(testing "linear-router"
(let [router (reitit/router ["/api" ["/ipa" ["/:size" ::beer]]])]
(is (= :linear-router (reitit/router-type router)))
(is (= [["/api/ipa/:size" {:name ::beer}]]
@ -40,7 +40,7 @@
#"^missing path-params for route /api/ipa/:size: \#\{:size\}$"
(reitit/match-by-name! router ::beer))))))
(testing "lookup router"
(testing "lookup-router"
(let [router (reitit/router ["/api" ["/ipa" ["/large" ::beer]]])]
(is (= :lookup-router (reitit/router-type router)))
(is (= [["/api/ipa/large" {:name ::beer}]]
@ -106,6 +106,13 @@
(is handler)
(is (= "ok" (handler)))))))
(testing "custom router"
(let [router (reitit/router ["/ping"] {:router (fn [_ _]
(reify Router
(reitit/router-type [_]
::custom)))})]
(is (= ::custom (reitit/router-type router)))))
(testing "bide sample"
(let [routes [["/auth/login" :auth/login]
["/auth/recovery/token/:token" :auth/recovery]
@ -138,3 +145,54 @@
:path "/api/user/1/2"
:params {:id "1", :sub-id "2"}})
(reitit/match-by-path router "/api/user/1/2"))))))
(deftest conflicting-routes-test
(are [conflicting? data]
(let [routes (reitit/resolve-routes data {})
conflicts (-> routes (reitit/resolve-routes {}) (reitit/conflicting-routes))]
(if conflicting? (seq conflicts) (nil? conflicts)))
true [["/a"]
["/a"]]
true [["/a"]
["/:b"]]
true [["/a"]
["/*b"]]
true [["/a/1/2"]
["/*b"]]
false [["/a"]
["/a/"]]
false [["/a"]
["/a/1"]]
false [["/a"]
["/a/:b"]]
false [["/a"]
["/a/*b"]]
true [["/v2/public/messages/dataset/bulk"]
["/v2/public/messages/dataset/:dataset-id"]])
(testing "all conflicts are returned"
(is (= {["/a" {}] #{["/*d" {}] ["/:b" {}]},
["/:b" {}] #{["/c" {}] ["/*d" {}]},
["/c" {}] #{["/*d" {}]}}
(-> [["/a"] ["/:b"] ["/c"] ["/*d"]]
(reitit/resolve-routes {})
(reitit/conflicting-routes)))))
(testing "router with conflicting routes"
(testing "throws by default"
(is (thrown-with-msg?
ExceptionInfo
#"router contains conflicting routes"
(reitit/router
[["/a"] ["/a"]]))))
(testing "can be configured to ignore"
(is (not (nil? (reitit/router [["/a"] ["/a"]] {:conflicts (constantly nil)})))))))