clojureify.clj

(ns node-tests.core
  (:refer-clojure :exclude [exists?])
  (:require [cljs.nodejs :as nodejs]
            [cljs.core.async :as async :refer [<!]])
  (:require-macros [cljs.core.async.macros :refer [go]]))

(nodejs/enable-util-print!)

;; Some helpers which help transform node style functions into clojurey ones
;;
(defn- wrap-val [v]
  (let [v (mapv #(js->clj % :keywordize-keys true) v)
        c (count v)
        f (first v)]
    (if (= 1 c) (first v) v)))


(defn clojureify-no-err [f]
  (fn [& args]
    (let [l (last args)]
      (if (ifn? l)
        (apply f args)
        (let [c (async/chan)
              g (fn [& res]
                  (async/put! c (wrap-val res) #(async/close! c)))]
          (apply f (concat args [g]))
          c)))))

(defn clojureify [f]
  (fn [& args]
    (let [l (last args)]
      (if (ifn? l)
        (apply f args)
        (let [c (async/chan)
              g (fn [err & res]
                  (async/put! c (or err
                                    (wrap-val res)) #(async/close! c)))]
          (apply f (concat args [g]))
          c)))))

(defn make-encodable! [t]
  (extend-type t 
    IEncodeClojure
    (-js->clj [x {:keys [keywordize-keys]}]
      (let [k (js/Object.keys x)
            keyfn (if keywordize-keys keyword str)]
        (into {} (for [_k k]
                   [(keyfn _k) (aget x _k)]))))))


; make some fs functions clojuery
;
(def fs (nodejs/require "fs"))
(make-encodable! fs.Stats)

(def exists? (clojureify-no-err fs.exists))
(def stat (clojureify fs.stat))

(defn -main []
  (go (println (<! (stat "/tmp")))))

(set! *main-cli-fn* -main)