export-refs.glisp

;; Template would be like below:

;; ###path/rect

;;    Generates a rect path

;; - **Alias:** `rect `- **Parameters:**

;; | Name | Type   | Description                                    |
;; | ---- | ------ | :--------------------------------------------- |
;; | Pos  | `vec2 `| coordinate of top-left corner of the rectangle |
;; | Size | `vec2 `| size of the rectangle                          |

(defn gen-param-column [idx param variadic]
  (if (= param &)
    nil
    (format "| %-8s | %-9s | %-12s |\n"
            (format "%s%s"
                    (if variadic "& " "")
                    (get param :label (format "%%%d" idx)))
            (str "`" (get param :type "") "`")
            (get param :desc ""))))

(defn gen-param-table [params]
  (if (not (sequential? params))
    nil
    (if (sequential? (first params))
      ;; Multi arity function
      (apply str
             (map #(->> %
                        (gen-param-table)
                        (format "%s\n"))
                  params))

      ;; Generates Table
      (str
       "| Name     | Type      | Description  |\n"
       "| -------- | --------- | :----------- |\n"
       (apply
        str
        (remove nil?
                (map-indexed
                 (fn [i p]
                   (gen-param-column
                    i p (and (> i 0)
                             (= & (nth params (dec i))))))
                 params)))
       "\n"))))

(defn upper-case [text]
  (js-eval (format "'%s'.toUpperCase()" text)))

(defn capital-case [text]
  (if (= 1 (count text))
    text
    (str (upper-case (subs text 0 1))
         (subs text 1))))

(defn gen-doc [sym m f]
  (apply
   str

   (remove
    nil?

    [(format "### %s\n\n" (name sym))

     (if (contains? m :doc)
       (format "%s\n\n" (get m :doc)))

     ;; Generate parameter table
     (let [fparams (fn-params f)
           params (or (get m :params)
                      (map #(hash-map) fparams))
           params (if (and fparams (>= (count fparams) (count params)))
                    (for [p params :index i]
                      (if (map? p)
                        (apply hash-map
                               (apply concat
                                      [:label (capital-case
                                               (print-str (nth fparams i)))]
                                      (entries p)))
                        p))
                    params)]
       (if (pos? (count params))
         (str
          "**Parameter**\n\n"
          (gen-param-table params))))

     (if (contains? m :return)
       (format "**Returns**: `%s`\n\n" (get (get m :return) :type)))

     (if (contains? m :alias)
       (format "**Alias:** `%s`\n\n" (get m :alias)))])))



(def md (->> (get-all-symbols)
             (sort)
             (map #(vector % (eval %)))
             (map #(vector (first %)         ; symbol
                           (meta (second %)) ; meta
                           (second %)))      ; function reference
             (remove #(nil? (second %))) ; Delete functions with no metadata
             (remove #(get (second %) :alias-for)) ; Delete aliased functions
             (map #(apply gen-doc %))))

(def txt (join "\n" md))

(spit "docs/ref.md" txt)