wip

Author: frenchy64

resources/clj-kondo.exports/metosin/compojure-api/compojure/api/meta.clj

@@ -0,0 +1,65 @@
+(ns compojure.api.meta
+  (:require [compojure.api.common :as common :refer [extract-parameters]]))
+
+(defmulti restructure-param
+  "Restructures a key value pair in smart routes. By default the key
+  is consumed form the :parameters map in acc. k = given key, v = value."
+  (fn [k v acc] k))
+
+(defn restructure [method [path arg & args] {:keys [context?]}]
+  (let [[options body] (extract-parameters args true)
+        [path-string lets arg-with-request arg] (destructure-compojure-api-request path arg)
+
+        {:keys [lets
+                letks
+                responses
+                middleware
+                middlewares
+                swagger
+                parameters
+                body]} (reduce
+                         (fn [acc [k v]]
+                           (restructure-param k v (update-in acc [:parameters] dissoc k)))
+                         {:lets lets
+                          :letks []
+                          :responses nil
+                          :middleware []
+                          :swagger {}
+                          :body body}
+                         options)
+
+        ;; migration helpers
+        _ (assert (not middlewares) ":middlewares is deprecated with 1.0.0, use :middleware instead.")
+        _ (assert (not parameters) ":parameters is deprecated with 1.0.0, use :swagger instead.")
+
+        ;; response coercion middleware, why not just code?
+        middleware (if (seq responses) (conj middleware `[coerce/body-coercer-middleware (common/merge-vector ~responses)]) middleware)]
+
+    (if context?
+
+      ;; context
+      (let [form `(compojure.core/routes ~@body)
+            form (if (seq letks) `(p/letk ~letks ~form) form)
+            form (if (seq lets) `(let ~lets ~form) form)
+            form (if (seq middleware) `((mw/compose-middleware ~middleware) ~form) form)
+            form `(compojure.core/context ~path ~arg-with-request ~form)
+
+            ;; create and apply a separate lookup-function to find the inner routes
+            childs (let [form (vec body)
+                         form (if (seq letks) `(dummy-letk ~letks ~form) form)
+                         form (if (seq lets) `(dummy-let ~lets ~form) form)
+                         form `(compojure.core/let-request [~arg-with-request ~'+compojure-api-request+] ~form)
+                         form `(fn [~'+compojure-api-request+] ~form)
+                         form `(~form {})]
+                     form)]
+
+        `(routes/create ~path-string ~method (merge-parameters ~swagger) ~childs ~form))
+
+      ;; endpoints
+      (let [form `(do ~@body)
+            form (if (seq letks) `(p/letk ~letks ~form) form)
+            form (if (seq lets) `(let ~lets ~form) form)
+            form (compojure.core/compile-route method path arg-with-request (list form))
+            form (if (seq middleware) `(compojure.core/wrap-routes ~form (mw/compose-middleware ~middleware)) form)]
+
+        `(routes/create ~path-string ~method (merge-parameters ~swagger) nil ~form)))))

resources/clj-kondo.exports/metosin/compojure/api/core.clj

@@ -0,0 +1,53 @@
+(ns compojure.api.core
+  (:require [compojure.api.meta :as meta]
+            [compojure.api.routes :as-alias routes]
+            [compojure.api.middleware :as-alias mw]))
+
+;; simulate clojure.tools.macro/name-with-attributes
+(defn- name-with-attributes [name routes]
+  (let [routes (cond-> routes
+                 (string? (first routes)) next)
+        routes (cond-> routes
+                 (map? (first routes)) next)]
+    [name routes]))
+
+(defmacro defroutes
+  "Define a Ring handler function from a sequence of routes.
+  The name may optionally be followed by a doc-string and metadata map."
+  {:style/indent 1}
+  [name & routes]
+  (let [[name routes] (name-with-attributes name routes)]
+    `(def ~name (routes ~@routes))))
+
+(defmacro let-routes
+  "Takes a vector of bindings and a body of routes.
+
+  Equivalent to: `(let [...] (routes ...))`"
+  {:style/indent 1}
+  [bindings & body]
+  `(let ~bindings (routes ~@body)))
+
+(defmacro middleware
+  "Wraps routes with given middlewares using thread-first macro.
+
+  Note that middlewares will be executed even if routes in body
+  do not match the request uri. Be careful with middleware that
+  has side-effects."
+  {:style/indent 1
+   :deprecated "1.1.14"
+   :superseded-by "route-middleware"}
+  [middleware & body]
+  `(let [body# (routes ~@body)
+         wrap-mw# (mw/compose-middleware ~middleware)]
+     (routes/create nil nil {} [body#] (wrap-mw# body#))))
+
+(defmacro context {:style/indent 2} [& args] (meta/restructure nil args {:context? true :&form &form :&env &env}))
+
+(defmacro GET     {:style/indent 2} [& args] (meta/restructure :get     args nil))
+(defmacro ANY     {:style/indent 2} [& args] (meta/restructure nil      args nil))
+(defmacro HEAD    {:style/indent 2} [& args] (meta/restructure :head    args nil))
+(defmacro PATCH   {:style/indent 2} [& args] (meta/restructure :patch   args nil))
+(defmacro DELETE  {:style/indent 2} [& args] (meta/restructure :delete  args nil))
+(defmacro OPTIONS {:style/indent 2} [& args] (meta/restructure :options args nil))
+(defmacro POST    {:style/indent 2} [& args] (meta/restructure :post    args nil))
+(defmacro PUT     {:style/indent 2} [& args] (meta/restructure :put     args nil))

resources/clj-kondo.exports/metosin/config.edn

@@ -0,0 +1,3 @@
+{:hooks
+ {:macroexpand
+  {compojure.api.core/defroutes compojure.api.core/defroutes}}}

scripts/regen-kondo.clj

@@ -0,0 +1,10 @@
+#!/bin/bash
+
+set -e
+
+bb -f ./script/regen_kondo_config.clj
+
+mkdir -p resources/clj-kondo.exports/metosin/compojure-api/compojure/api
+
+;; rename to .clj
+cp src/compojure/api/common.cljc resources/clj-kondo.exports/metosin/compojure-api/compojure/api/common.clj

src/compojure/api/common.clj renamed to src/compojure/api/common.cljc

@@ -1,5 +1,6 @@
 (ns compojure.api.common
-  (:require [linked.core :as linked]))
+  #?@(:bb []
+      :default [(:require [linked.core :as linked])]))
 
 (defn plain-map?
   "checks whether input is a map, but not a record"
@@ -51,6 +52,8 @@
     x
     y))
 
+#?(:bb nil
+   :default
 (defn fifo-memoize [f size]
   "Returns a memoized version of a referentially transparent f. The
   memoized version of the function keeps a cache of the mapping from arguments
@@ -66,6 +69,7 @@
                                (dissoc mem (-> mem first first))
                                mem))))
             value)))))
+)
 
 ;; NB: when-ns eats all exceptions inside the body, including those about
 ;; unresolvable symbols. Keep this in mind when debugging the definitions below.