Merge branch 'cljs-2615'

Author: swannodette

src/main/clojure/cljs/build/api.clj

@@ -132,7 +132,7 @@
    (closure/source-for-namespace ns compiler-env)))
 
 (defn add-dependencies
-  "Given one or more IJavaScript objects in dependency order, produce
+  "DEPRECATED: Given one or more IJavaScript objects in dependency order, produce
   a new sequence of IJavaScript objects which includes the input list
   plus all dependencies in dependency order."
   [opts & ijss]

src/main/clojure/cljs/closure.clj

@@ -7,32 +7,6 @@
 ;   You must not remove this notice, or any other, from this software.
 
 (ns cljs.closure
-  "Compile ClojureScript to JavaScript with optimizations from Google
-   Closure Compiler producing runnable JavaScript.
-
-   The Closure Compiler (compiler.jar) must be on the classpath.
-
-   Use the 'build' function for end-to-end compilation.
-
-   build = find-sources -> add-dependencies -> compile -> optimize -> output
-
-   Two protocols are defined: IJavaScript and Compilable. The
-   Compilable protocol is satisfied by something which can return one
-   or more IJavaScripts.
-
-   With IJavaScript objects in hand, calling add-dependencies will
-   produce a sequence of IJavaScript objects which includes all
-   required dependencies from the Closure library and ClojureScript,
-   in dependency order. This function replaces the closurebuilder
-   tool.
-
-   The optimize function converts one or more IJavaScripts into a
-   single string of JavaScript source code using the Closure Compiler
-   API.
-
-   The produced output is either a single string of optimized
-   JavaScript or a deps file for use during development.
-  "
   (:refer-clojure :exclude [compile])
   (:require [cljs.util :as util :refer [distinct-by]]
             [cljs.core :as cljsm]
@@ -546,6 +520,11 @@
   [compilable opts]
   (-compile compilable opts))
 
+(defn find-sources
+  "Given a Compilable, find sources and return a sequence of IJavaScript."
+  [compilable opts]
+  (-find-sources compilable opts))
+
 (defn compile-file
   "Compile a single cljs file. If no output-file is specified, returns
   a string of compiled JavaScript. With an output-file option, the
@@ -724,7 +703,7 @@
   (js-dependencies {:libs ["closure/library/third_party/closure"]} ["goog.dom.query"])
   )
 
-(defn- add-core-macros-if-cljs-js
+(defn add-core-macros-if-cljs-js
   "If a compiled entity is the cljs.js namespace, explicitly
   add the cljs.core macros namespace dependency to it."
   [compiled]
@@ -856,10 +835,8 @@
   (let [url (deps/to-url (constants-filename opts))]
     (javascript-file nil url [(str ana/constants-ns-sym)] ["cljs.core"])))
 
-;; Internally only REPLs use this. We do expose it in cljs.build.api - David
-
 (defn add-dependencies
-  "Given one or more IJavaScript objects in dependency order, produce
+  "DEPRECATED: Given one or more IJavaScript objects in dependency order, produce
   a new sequence of IJavaScript objects which includes the input list
   plus all dependencies in dependency order."
   [opts & inputs]
@@ -1065,30 +1042,6 @@
          (str "#!" (or hashbang "/usr/bin/env node") "\n"))
        (when preamble (preamble-from-paths preamble))))
 
-(comment
-  ;; add dependencies to literal js
-  (add-dependencies {} "goog.provide('test.app');\ngoog.require('cljs.core');")
-  (add-dependencies {} "goog.provide('test.app');\ngoog.require('goog.array');")
-  (add-dependencies {} (str "goog.provide('test.app');\n"
-                            "goog.require('goog.array');\n"
-                            "goog.require('clojure.set');"))
-  ;; add dependencies with external lib
-  (add-dependencies {:libs ["closure/library/third_party/closure"]}
-                    (str "goog.provide('test.app');\n"
-                         "goog.require('goog.array');\n"
-                         "goog.require('goog.dom.query');"))
-  ;; add dependencies with foreign lib
-  (add-dependencies {:foreign-libs [{:file "samples/hello/src/hello/core.cljs"
-                                     :provides ["example.lib"]}]}
-                    (str "goog.provide('test.app');\n"
-                         "goog.require('example.lib');\n"))
-  ;; add dependencies to a JavaScriptFile record
-  (add-dependencies {} (javascript-file false
-                                        (deps/to-url "samples/hello/src/hello/core.cljs")
-                                        ["hello.core"]
-                                        ["goog.array"]))
-  )
-
 ;; Optimize
 ;; ========
 
@@ -1438,11 +1391,6 @@
 
   ;; optimize a ClojureScript form
   (optimize {:optimizations :simple} (-compile '(def x 3) {}))
-
-  ;; optimize a project
-  (println (->> (-compile "samples/hello/src" {})
-                (apply add-dependencies {})
-                (apply optimize {:optimizations :simple :pretty-print true})))
   )
 
 ;; Output
@@ -1972,24 +1920,6 @@
 
       :else (output-deps-file opts disk-sources))))
 
-(comment
-
-  ;; output unoptimized alone
-  (output-unoptimized {} "goog.provide('test');\ngoog.require('cljs.core');\nalert('hello');\n")
-  ;; output unoptimized with all dependencies
-  (apply output-unoptimized {}
-         (add-dependencies {}
-                           "goog.provide('test');\ngoog.require('cljs.core');\nalert('hello');\n"))
-  ;; output unoptimized with external library
-  (apply output-unoptimized {}
-         (add-dependencies {:libs ["closure/library/third_party/closure"]}
-                           "goog.provide('test');\ngoog.require('cljs.core');\ngoog.require('goog.dom.query');\n"))
-  ;; output unoptimized and write deps file to 'out/test.js'
-  (output-unoptimized {:output-to "out/test.js"}
-                      "goog.provide('test');\ngoog.require('cljs.core');\nalert('hello');\n")
-  )
-
-
 (defn get-upstream-deps*
   "returns a merged map containing all upstream dependencies defined
   by libraries on the classpath."
@@ -2706,15 +2636,17 @@
                        (:foreign-libs opts)))
                (process-js-modules opts)
                (:options @compiler-env))]
-    (swap! compiler-env (fn [cenv]
-                          (-> cenv
-                            ;; we need to also track the whole top level - this is to support
-                            ;; cljs.analyze/analyze-deps, particularly in REPL contexts - David
-                            (merge {:js-dependency-index (deps/js-dependency-index opts)})
-                            (update-in [:node-module-index] (fnil into #{})
-                              (if (= target :nodejs)
-                                (map str node-required)
-                                (map str (keys top-level)))))))
+    (swap! compiler-env
+      (fn [cenv]
+        (-> cenv
+          ;; we need to also track the whole top level - this is to support
+          ;; cljs.analyze/analyze-deps, particularly in REPL contexts - David
+          (merge {:js-dependency-index (deps/js-dependency-index opts)})
+          (update-in [:options] merge opts)
+          (update-in [:node-module-index] (fnil into #{})
+            (if (= target :nodejs)
+              (map str node-required)
+              (map str (keys top-level)))))))
     opts))
 
 (defn output-bootstrap [{:keys [target] :as opts}]
@@ -2726,6 +2658,27 @@
       (util/mkdirs outfile)
       (spit outfile (slurp (io/resource (str "cljs/bootstrap_" target-str ".js")))))))
 
+(defn compile-inputs
+  "Compile inputs and all of their transitive dependencies including JS modules,
+   libs, and foreign libs. Duplicates the pipeline of build."
+  [inputs opts]
+  (env/ensure
+    (let [sources (-> inputs (add-dependency-sources opts))
+          opts    (handle-js-modules opts sources env/*compiler*)
+          sources (-> (remove (comp #{:seed} :type) sources)
+                    deps/dependency-order
+                    (compile-sources false opts)
+                    (#(map add-core-macros-if-cljs-js %))
+                    (add-js-sources opts) deps/dependency-order
+                    (->> (map #(source-on-disk opts %)) doall))]
+      sources)))
+
+(defn compile-ns
+  "Compiles a namespace and all of its transitive dependencies.
+   See compile-inputs."
+  [ns opts]
+  (compile-inputs (find-sources ns opts) opts))
+
 (defn build
   "Given a source which can be compiled, produce runnable JavaScript."
   ([source opts]
@@ -2818,7 +2771,6 @@
                               (-> (-find-sources source opts)
                                   (add-dependency-sources compile-opts)))
                  opts       (handle-js-modules opts js-sources compiler-env)
-                 _ (swap! env/*compiler* update-in [:options] merge opts)
                  js-sources (-> js-sources
                                 deps/dependency-order
                                 (compile-sources compiler-stats compile-opts)

src/main/clojure/cljs/repl.cljc

@@ -196,28 +196,19 @@
   only once."
   ([repl-env ns] (load-namespace repl-env ns nil))
   ([repl-env ns opts]
-   (let [ns (if (and (seq? ns)
-                     (= (first ns) 'quote))
-               (second ns)
-               ns)
-         ;; TODO: add pre-condition to source-on-disk, the
-         ;; source must supply at least :url - David
-         sources (binding [ana/*analyze-deps* false]
-                   (cljsc/add-dependencies
-                     (merge (env->opts repl-env) opts)
-                     {:requires [(name ns)] :type :seed}))
-         deps (->> sources
-                (remove (comp #{["goog"]} :provides))
-                (remove (comp #{:seed} :type))
-                (map #(select-keys % [:provides :url])))]
-     (cljsc/handle-js-modules opts sources env/*compiler*)
+   (let [ns (if (and (seq? ns) (= (first ns) 'quote)) (second ns) ns)
+         ;; We need to use a seed because many things (npm deps etc.) cannot be
+         ;; *directly* compiled, they must be a part of some ClojureScript ns
+         ;; form - thus we fabricate a seed
+         sources (->> (cljsc/compile-inputs
+                        [{:requires [(name ns)] :type :seed}]
+                        (merge (env->opts repl-env) opts))
+                   (remove (comp #{["goog"]} :provides)))]
      (if (:output-dir opts)
        ;; REPLs that read from :output-dir just need to add deps,
        ;; environment will handle actual loading - David
        (let [sb (StringBuffer.)]
-         (doseq [source (->> sources
-                          (remove (comp #{:seed} :type))
-                          (map #(cljsc/source-on-disk opts %)))]
+         (doseq [source sources]
            (when (:repl-verbose opts)
              (println "Loading:" (:provides source)))
            ;; Need to get :requires and :provides from compiled source
@@ -233,7 +224,7 @@
            (println (.toString sb)))
          (-evaluate repl-env "<cljs repl>" 1 (.toString sb)))
        ;; REPLs that stream must manually load each dep - David
-       (doseq [{:keys [url provides]} deps]
+       (doseq [{:keys [url provides]} sources]
          (-load repl-env provides url))))))
 
 (defn- load-dependencies
@@ -502,8 +493,11 @@
            ast (->ast form)
            ast (if-not (#{:ns :ns*} (:op ast))
                  ast
-                 (let [ijs (ana/parse-ns [form])] ;; if ns form need to check for js modules - David
-                   (cljsc/handle-js-modules opts [ijs] env/*compiler*)
+                 (let [ijs (ana/parse-ns [form])]
+                   (cljsc/handle-js-modules opts
+                     (deps/dependency-order
+                       (cljsc/add-dependency-sources [ijs] opts))
+                     env/*compiler*)
                    (binding [ana/*check-alias-dupes* false]
                      (ana/no-warn (->ast form))))) ;; need new AST after we know what the modules are - David
            wrap-js