clementine 0.0.1 → 0.0.2

data/{vendor/assets → ext/clojure-clojurescript-bef56a7}/src/clj/cljs/repl.clj

@@ -8,9 +8,12 @@
 
 (ns cljs.repl
   (:refer-clojure :exclude [load-file])
+  (:import java.io.File)
   (:require [clojure.string :as string]
             [clojure.java.io :as io]
             [cljs.compiler :as comp]
+            [cljs.analyzer :as ana]
+            [cljs.tagged-literals :as tags]
             [cljs.closure :as cljsc]))
 
 (def ^:dynamic *cljs-verbose* false)
@@ -61,11 +64,17 @@
      (evaluate-form repl-env env filename form identity))
   ([repl-env env filename form wrap]
      (try
-       (let [ast (comp/analyze env form)
-             js (comp/emits ast)
-             wrap-js (comp/emits (comp/analyze env (wrap form)))]
+       (let [ast (ana/analyze env form)
+             js (comp/emit-str ast)
+             wrap-js (comp/emit-str (binding [ana/*cljs-warn-on-undeclared* false
+                                              ana/*cljs-warn-on-redef* false
+                                              ana/*cljs-warn-on-dynamic* false
+                                              ana/*cljs-warn-on-fn-var* false
+                                              ana/*cljs-warn-fn-arity* false]
+                                   (ana/analyze env (wrap form))))]
          (when (= (:op ast) :ns)
-           (load-dependencies repl-env (vals (:requires ast))))
+           (load-dependencies repl-env (into (vals (:requires ast))
+                                             (distinct (vals (:uses ast))))))
          (when *cljs-verbose*
            (print js))
          (let [ret (-evaluate repl-env filename (:line (meta form)) wrap-js)]
@@ -84,18 +93,18 @@
 
 (defn load-stream [repl-env filename stream]
   (with-open [r (io/reader stream)]
-    (let [env {:ns (@comp/namespaces comp/*cljs-ns*) :context :statement :locals {}}
+    (let [env (ana/empty-env)
           pbr (clojure.lang.LineNumberingPushbackReader. r)
           eof (Object.)]
       (loop [r (read pbr false eof false)]
-        (let [env (assoc env :ns (@comp/namespaces comp/*cljs-ns*))]
+        (let [env (assoc env :ns (ana/get-namespace ana/*cljs-ns*))]
           (when-not (identical? eof r)
             (evaluate-form repl-env env filename r)
             (recur (read pbr false eof false))))))))
 
 (defn load-file
   [repl-env f]
-  (binding [comp/*cljs-ns* 'cljs.user]
+  (binding [ana/*cljs-ns* 'cljs.user]
     (let [res (if (= \/ (first f)) f (io/resource f))]
       (assert res (str "Can't find " f " in classpath"))
       (load-stream repl-env f res))))
@@ -112,7 +121,7 @@
 
 (defn- eval-and-print [repl-env env form]
   (let [ret (evaluate-form repl-env
-                           (assoc env :ns (@comp/namespaces comp/*cljs-ns*))
+                           (assoc env :ns (ana/get-namespace ana/*cljs-ns*))
                            "<cljs repl>"
                            form
                            (wrap-fn form))]
@@ -123,39 +132,56 @@
              (prn nil))))))
 
 (defn- read-next-form []
-  (try {:status :success :form (binding [*ns* (create-ns comp/*cljs-ns*)]
+  (try {:status :success :form (binding [*ns* (create-ns ana/*cljs-ns*)
+                                         *data-readers* tags/*cljs-data-readers*]
                                  (read))}
        (catch Exception e
          (println (.getMessage e))
          {:status :error})))
 
+(def default-special-fns
+  (let [load-file-fn (fn [repl-env file] (load-file repl-env file))]
+    {'in-ns (fn [_ quoted-ns]
+              (let [ns-name (second quoted-ns)]
+                (when-not (ana/get-namespace ns-name)
+                  (ana/set-namespace ns-name {:name ns-name}))
+                (set! ana/*cljs-ns* ns-name)))
+     'load-file load-file-fn
+     'clojure.core/load-file load-file-fn
+     'load-namespace (fn [repl-env ns] (load-namespace repl-env ns))}))
+
+(defn analyze-source
+  "Given a source directory, analyzes all .cljs files. Used to populate
+  cljs.analyzer/namespaces so as to support code reflection."
+  [src-dir]
+  (if-let [src-dir (and (not (empty? src-dir))
+                     (File. src-dir))]
+    (doseq [file (comp/cljs-files-in src-dir)]
+      (ana/analyze-file (str "file://" (.getAbsolutePath file))))))
+
 (defn repl
   "Note - repl will reload core.cljs every time, even if supplied old repl-env"
-  [repl-env & {:keys [verbose warn-on-undeclared]}]
+  [repl-env & {:keys [verbose warn-on-undeclared special-fns]}]
   (prn "Type: " :cljs/quit " to quit")
-  (binding [comp/*cljs-ns* 'cljs.user
+  (binding [ana/*cljs-ns* 'cljs.user
             *cljs-verbose* verbose
-            comp/*cljs-warn-on-undeclared* warn-on-undeclared]
-    (let [env {:context :statement :locals {}}]
+            ana/*cljs-warn-on-undeclared* warn-on-undeclared]
+    (let [env {:context :statement :locals {}}
+          special-fns (merge default-special-fns special-fns)
+          is-special-fn? (set (keys special-fns))]
       (-setup repl-env)
       (loop []
-        (print (str "ClojureScript:" comp/*cljs-ns* "> "))
+        (print (str "ClojureScript:" ana/*cljs-ns* "> "))
         (flush)
         (let [{:keys [status form]} (read-next-form)]
           (cond
            (= form :cljs/quit) :quit
-           
+
            (= status :error) (recur)
-           
-           (and (seq? form) (= (first form) 'in-ns))
-           (do (set! comp/*cljs-ns* (second (second form))) (newline) (recur))
-           
-           (and (seq? form) ('#{load-file clojure.core/load-file} (first form)))
-           (do (load-file repl-env (second form)) (newline) (recur))
-           
-           (and (seq? form) ('#{load-namespace} (first form)))
-           (do (load-namespace repl-env (second form)) (newline) (recur))
-           
+
+           (and (seq? form) (is-special-fn? (first form)))
+           (do (apply (get special-fns (first form)) repl-env (rest form)) (newline) (recur))
+
            :else
            (do (eval-and-print repl-env env form) (recur)))))
       (-tear-down repl-env))))

data/ext/clojure-clojurescript-bef56a7/src/clj/cljs/repl/browser.clj

@@ -0,0 +1,258 @@
+;; Copyright (c) Rich Hickey. All rights reserved.
+;; The use and distribution terms for this software are covered by the
+;; Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php)
+;; which can be found in the file epl-v10.html at the root of this distribution.
+;; By using this software in any fashion, you are agreeing to be bound by
+;; the terms of this license.
+;; You must not remove this notice, or any other, from this software.
+
+(ns cljs.repl.browser
+  (:refer-clojure :exclude [loaded-libs])
+  (:require [clojure.java.io :as io]
+            [cljs.compiler :as comp]
+            [cljs.closure :as cljsc]
+            [cljs.repl :as repl]
+            [cljs.repl.server :as server])
+  (:import cljs.repl.IJavaScriptEnv))
+
+(defonce browser-state (atom {:return-value-fn nil
+                              :client-js nil}))
+
+(def loaded-libs (atom #{}))
+(def preloaded-libs (atom #{}))
+
+(defn- set-return-value-fn
+  "Save the return value function which will be called when the next
+  return value is received."
+  [f]
+  (swap! browser-state (fn [old] (assoc old :return-value-fn f))))
+
+(defn send-for-eval
+  "Given a form and a return value function, send the form to the
+  browser for evaluation. The return value function will be called
+  when the return value is received."
+  ([form return-value-fn]
+     (send-for-eval @(server/connection) form return-value-fn))
+  ([conn form return-value-fn]
+     (do (set-return-value-fn return-value-fn)
+         (server/send-and-close conn 200 form "text/javascript"))))
+
+(defn- return-value
+  "Called by the server when a return value is received."
+  [val]
+  (when-let [f (:return-value-fn @browser-state)]
+    (f val)))
+
+(defn repl-client-js []
+  (slurp @(:client-js @browser-state)))
+
+(defn send-repl-client-page
+  [request conn opts]
+  (server/send-and-close conn 200
+    (str "<html><head><meta charset=\"UTF-8\"></head><body>
+          <script type=\"text/javascript\">"
+         (repl-client-js)
+         "</script>"
+         "<script type=\"text/javascript\">
+          clojure.browser.repl.client.start(\"http://" (-> request :headers :host) "\");
+          </script>"
+         "</body></html>")
+    "text/html"))
+
+(defn send-static [{path :path :as request} conn opts]
+  (if (and (:static-dir opts)
+           (not= "/favicon.ico" path))
+    (let [path   (if (= "/" path) "/index.html" path)
+          st-dir (:static-dir opts)]
+      (if-let [local-path (seq (for [x (if (string? st-dir) [st-dir] st-dir)
+                                     :when (.exists (io/file (str x path)))]
+                                 (str x path)))]
+        (server/send-and-close conn 200 (slurp (first local-path))
+                        (condp #(.endsWith %2 %1) path
+                          ".html" "text/html"
+                          ".css" "text/css"
+                          ".html" "text/html"
+                          ".jpg" "image/jpeg"
+                          ".js" "text/javascript"
+                          ".png" "image/png"
+                          "text/plain"))
+        (server/send-404 conn path)))
+    (server/send-404 conn path)))
+
+(server/dispatch-on :get
+                    (fn [{:keys [path]} _ _] (.startsWith path "/repl"))
+                    send-repl-client-page)
+
+(server/dispatch-on :get
+                    (fn [{:keys [path]} _ _] (or (= path "/")
+                                                (.endsWith path ".js")
+                                                (.endsWith path ".html")))
+                    send-static)
+
+(defmulti handle-post (fn [m _ _ ] (:type m)))
+
+(server/dispatch-on :post (constantly true) handle-post)
+
+(def ordering (agent {:expecting nil :fns {}}))
+
+(defmethod handle-post :ready [_ conn _]
+  (do (reset! loaded-libs @preloaded-libs)
+      (send ordering (fn [_] {:expecting nil :fns {}}))
+      (send-for-eval conn
+                     (cljsc/-compile
+                      '[(ns cljs.user)
+                        (set! *print-fn* clojure.browser.repl/repl-print)] {})
+                     identity)))
+
+(defn add-in-order [{:keys [expecting fns]} order f]
+  {:expecting (or expecting order) :fns (assoc fns order f)})
+
+(defn run-in-order [{:keys [expecting fns]}]
+  (loop [order expecting
+         fns fns]
+    (if-let [f (get fns order)]
+      (do (f)
+          (recur (inc order) (dissoc fns order)))
+      {:expecting order :fns fns})))
+
+(defn constrain-order
+  "Elements to be printed in the REPL will arrive out of order. Ensure
+  that they are printed in the correct order."
+  [order f]
+  (send-off ordering add-in-order order f)
+  (send-off ordering run-in-order))
+
+(defmethod handle-post :print [{:keys [content order]} conn _ ]
+  (do (constrain-order order (fn [] (do (print (read-string content))
+                                       (.flush *out*))))
+      (server/send-and-close conn 200 "ignore__")))
+
+(defmethod handle-post :result [{:keys [content order]} conn _ ]
+  (constrain-order order (fn [] (do (return-value content)
+                                   (server/set-connection conn)))))
+
+(defn browser-eval
+  "Given a string of JavaScript, evaluate it in the browser and return a map representing the
+   result of the evaluation. The map will contain the keys :type and :value. :type can be
+   :success, :exception, or :error. :success means that the JavaScript was evaluated without
+   exception and :value will contain the return value of the evaluation. :exception means that
+   there was an exception in the browser while evaluating the JavaScript and :value will
+   contain the error message. :error means that some other error has occured."
+  [form]
+  (let [return-value (promise)]
+    (send-for-eval form
+                   (fn [val] (deliver return-value val)))
+    (let [ret @return-value]
+      (try (read-string ret)
+           (catch Exception e
+             {:status :error
+              :value (str "Could not read return value: " ret)})))))
+
+(defn load-javascript
+  "Accepts a REPL environment, a list of namespaces, and a URL for a
+  JavaScript file which contains the implementation for the list of
+  namespaces. Will load the JavaScript file into the REPL environment
+  if any of the namespaces have not already been loaded from the
+  ClojureScript REPL."
+  [repl-env ns-list url]
+  (let [missing (remove #(contains? @loaded-libs %) ns-list)]
+    (when (seq missing)
+      (browser-eval (slurp url))
+      (swap! loaded-libs (partial apply conj) missing))))
+
+(defrecord BrowserEnv []
+  repl/IJavaScriptEnv
+  (-setup [this]
+    (do (require 'cljs.repl.reflect)
+        (repl/analyze-source (:src this))
+        (comp/with-core-cljs (server/start this))))
+  (-evaluate [_ _ _ js] (browser-eval js))
+  (-load [this ns url] (load-javascript this ns url))
+  (-tear-down [_]
+    (do (server/stop)
+        (reset! server/state {})
+        (reset! browser-state {}))))
+
+(defn compile-client-js [opts]
+  (cljsc/build '[(ns clojure.browser.repl.client
+                   (:require [goog.events :as event]
+                             [clojure.browser.repl :as repl]))
+                 (defn start [url]
+                   (event/listen js/window
+                                 "load"
+                                 (fn []
+                                   (repl/start-evaluator url))))]
+               {:optimizations (:optimizations opts)
+                :output-dir (:working-dir opts)}))
+
+(defn create-client-js-file [opts file-path]
+  (let [file (io/file file-path)]
+    (when (not (.exists file))
+      (spit file (compile-client-js opts)))
+    file))
+
+(defn- provides-and-requires
+  "Return a flat list of all provided and required namespaces from a
+  sequence of IJavaScripts."
+  [deps]
+  (flatten (mapcat (juxt :provides :requires) deps)))
+
+(defn- always-preload
+  "Return a list of all namespaces which are always loaded into the browser
+  when using a browser-connected REPL."
+  []
+  (let [cljs (provides-and-requires (cljsc/cljs-dependencies {} ["clojure.browser.repl"]))
+        goog (provides-and-requires (cljsc/js-dependencies {} cljs))]
+    (disj (set (concat cljs goog)) nil)))
+
+(defn repl-env
+  "Create a browser-connected REPL environment.
+
+  Options:
+
+  port:           The port on which the REPL server will run. Defaults to 9000.
+  working-dir:    The directory where the compiled REPL client JavaScript will
+                  be stored. Defaults to \".repl\".
+  serve-static:   Should the REPL server attempt to serve static content?
+                  Defaults to true.
+  static-dir:     List of directories to search for static content. Defaults to
+                  [\".\" \"out/\"].
+  preloaded-libs: List of namespaces that should not be sent from the REPL server
+                  to the browser. This may be required if the browser is already
+                  loading code and reloading it would cause a problem.
+  optimizations:  The level of optimization to use when compiling the client
+                  end of the REPL. Defaults to :simple.
+  src:            The source directory containing user-defined cljs files. Used to
+                  support reflection. Defaults to \"src/\".
+  "
+  [& {:as opts}]
+  (let [opts (merge (BrowserEnv.)
+                    {:port          9000
+                     :optimizations :simple
+                     :working-dir   ".repl"
+                     :serve-static  true
+                     :static-dir    ["." "out/"]
+                     :preloaded-libs   []
+                     :src           "src/"}
+                    opts)]
+    (do (reset! preloaded-libs (set (concat (always-preload) (map str (:preloaded-libs opts)))))
+        (reset! loaded-libs @preloaded-libs)
+        (swap! browser-state
+               (fn [old] (assoc old :client-js
+                               (future (create-client-js-file
+                                        opts
+                                        (io/file (:working-dir opts) "client.js"))))))
+        opts)))
+
+(comment
+
+  (require '[cljs.repl :as repl])
+  (require '[cljs.repl.browser :as browser])
+  (def env (browser/repl-env))
+  (repl/repl env)
+  ;; simulate the browser with curl
+  ;; curl -v -d "ready" http://127.0.0.1:9000
+  ClojureScript:> (+ 1 1)
+  ;; curl -v -d "2" http://127.0.0.1:9000
+
+  )

data/ext/clojure-clojurescript-bef56a7/src/clj/cljs/repl/reflect.clj

@@ -0,0 +1,75 @@
+(ns cljs.repl.reflect
+  (:refer-clojure :exclude [macroexpand])
+  (:require [cljs.repl.server :as server]
+            [cljs.analyzer :as analyzer]
+            [cljs.compiler :as compiler]
+            [clojure.string :as str]
+            [clojure.pprint :as pprint]))
+
+(defn- dissoc-unless
+  "Dissoc all keys from map that do not appear in key-set.
+
+    (dissoc-unless {:foo 1 :bar 2} #{:foo})
+    => {:foo 1}"
+  [m key-set]
+  {:pre [(map? m)
+         (set? key-set)]}
+  (reduce (fn [coll key]
+            (if (contains? key-set key)
+              coll
+              (dissoc coll key)))
+          m (keys m)))
+
+(defn- get-meta [sym]
+  (let [ns (symbol (namespace sym))
+        n  (symbol (name sym))]
+    (if-let [sym-meta (get (:defs (get @analyzer/namespaces ns)) n)]
+      (-> (dissoc-unless sym-meta
+                         #{:name :method-params :doc :line :file})
+          (update-in [:name] str)
+          (update-in [:method-params] #(str (vec %)))))))
+
+(defn macroexpand [form]
+  "Fully expands a cljs macro form."
+  (let [mform (analyzer/macroexpand-1 {} form)]
+    (if (identical? form mform)
+      mform
+      (macroexpand mform))))
+
+(defn- url-decode [encoded & [encoding]]
+  (java.net.URLDecoder/decode encoded (or encoding "UTF-8")))
+
+(def read-url-string (comp read-string url-decode))
+
+(defn parse-param
+  "Parses the query parameter of a path of the form \"/reflect?var=foo\"
+  into the vector [\"var\" \"foo\"]."
+  [path]
+  (-> (str/split path #"\?")
+      (last)
+      (str/split #"=")))
+
+(defn- compile-and-return
+  "Compiles a form to javascript and returns it on conn."
+  [conn form]
+  (let [ast (analyzer/analyze {:ns {:name 'cljs.user}} form)
+        js  (try (compiler/emit-str ast)
+                 (catch Exception e (println e)))]
+    (server/send-and-close conn 200 js "text/javascript")))
+
+(defmulti handle-reflect-query (fn [[param _] & _] param))
+
+(defmethod handle-reflect-query "var"
+  [[_ sym] req conn opts]
+  (let [sym (read-url-string sym)]
+    (compile-and-return conn (get-meta sym))))
+
+(defmethod handle-reflect-query "macroform"
+  [[_ mform] req conn opts]
+  (let [mform (-> mform read-url-string macroexpand)]
+    (server/send-and-close conn 200 (with-out-str (pprint/pprint mform)))))
+
+(server/dispatch-on :get
+                    (fn [{:keys [path]} _ _] (.startsWith path "/reflect"))
+                    (fn [{:keys [path] :as req} conn opts]
+                      (handle-reflect-query (parse-param path) req conn opts)))