kondo-log.clj

(ns town.lilac.kondo-log
  (:require
   [datascript.core :as d]))


(defn assoc-some
  "Associates one or more key-value pairs to the given map as long as
  value is non-nil."
  [m & kvs]
  (when-not (even? (count kvs))
    (throw (ex-info "assoc-some expects an even number of kv pairs" {})))
  (into (or m {})
        (comp
         (map vec)
         (filter (comp some? second)))
        (partition 2 kvs)))


(def schema
  {:ns/id {:db/unique :db.unique/identity}

   :ns.usage/id {:db/unique :db.unique/identity}
   :ns.usage/from {:db/valueType :db.type/ref}
   :ns.usage/to {:db/valueType :db.type/ref}

   :var/id {:db/unique :db.unique/identity}
   :var/ns {:db/valueType :db.type/ref}

   :var.usage/from {:db/valueType :db.type/ref}
   :var.usage/to {:db/valueType :db.type/ref}
   :var.usage/from-var {:db/valueType :db.type/ref}})


(defn ->ns-entity
  [{:keys [filename name lang meta]}]
  (assoc-some
    {:ns/id name
     :ns/name name
     :ns/filename filename}
    :ns/lang lang
    :ns/meta meta))


(defn ->var-entity
  [{:keys [filename ns name defined-by row col end-row end-col]}]
  (assoc-some
    {:var/id (symbol (str ns) (str name))
     :var/filename filename
     :var/ns #:ns{:id ns}
     :var/name name
     ;; could this be a ref?
     :var/defined-by defined-by}
    :var/row row
    :var/col col
    :var/end-row end-row
    :var/enc-col end-col))


(defn ->ns-usage-entity
  [{:keys [filename row col from to alias lang]}]
  (assoc-some
    {:ns.usage/id (str filename ":" row ":" col)
     :ns.usage/filename filename
     :ns.usage/row row
     :ns.usage/col col
     :ns.usage/from #:ns{:id from}
     :ns.usage/to #:ns{:id to}}
    :ns.usage/alias alias
    :ns.usage/lang lang))


(defn ->var-usage-entity
  [{:keys [filename name row col end-row end-col name-row name-col name-end-row
           name-end-col from to from-var]}]
  (assoc-some
    {:var.usage/filename filename
     :var.usage/name name}
    :var.usage/from (when from {:ns/id from})
    :var.usage/to (when to {:ns/id to})
    :var.usage/from-var (when (and from from-var)
                          {:var/id (symbol (str from) (str from-var))})
    :var.usage/row row
    :var.usage/col col
    :var.usage/end-row end-row
    :var.usage/end-col end-col
    :var.usage/name-row name-row
    :var.usage/name-col name-col
    :var.usage/name-end-row name-end-row
    :var.usage/name-end-col name-end-col))


(defn transact-analysis!
  [conn analysis]
  (d/transact! conn
               (concat
                 (map ->ns-entity (get analysis :namespace-definitions))
                 (map ->ns-usage-entity (get analysis :namespace-usages))
                 (map ->var-entity (get analysis :var-definitions))
                 (mapv ->var-usage-entity (get analysis :var-usages)))))