Added support for google closure compilation of foreign libraries

src/clj/cljs/closure.clj

@@ -161,6 +161,8 @@
 (defmethod to-url String [s] (to-url (io/file s)))
 
 (defprotocol IJavaScript
+ (-foreign? [this] "Whether the Javascript represents a foreign
+ library (a js file that not have any goog.provide statement")
  (-url [this] "The URL where this JavaScript is located. Returns nil
  when JavaScript exists in memory only.")
  (-provides [this] "A list of namespaces that this JavaScript provides.")
@@ -170,12 +172,14 @@
 (extend-protocol IJavaScript
 
  String
+ (-foreign? [this] false)
  (-url [this] nil)
  (-provides [this] (:provides (parse-js-ns (string/split-lines this))))
  (-requires [this] (:requires (parse-js-ns (string/split-lines this))))
  (-source [this] this)
 
  clojure.lang.IPersistentMap
+ (-foreign? [this] (:foreign this))
  (-url [this] (or (:url this)
  (to-url (:file this))))
  (-provides [this] (map name (:provides this)))
@@ -184,18 +188,20 @@
  s
  (slurp (io/reader (-url this))))))
 
-(defrecord JavaScriptFile [^URL url provides requires]
+(defrecord JavaScriptFile [foreign ^URL url provides requires]
  IJavaScript
+ (-foreign? [this] foreign)
  (-url [this] url)
  (-provides [this] provides)
  (-requires [this] requires)
  (-source [this] (slurp (io/reader url))))
 
-(defn javascript-file [^URL url provides requires]
- (JavaScriptFile. url (map name provides) (map name requires)))
+(defn javascript-file [foreign ^URL url provides requires]
+ (JavaScriptFile. foreign url (map name provides) (map name requires)))
 
 (defn map->javascript-file [m]
- (javascript-file (to-url (:file m))
+ (javascript-file (:foreign m)
+ (to-url (:file m))
  (:provides m)
  (:requires m)))
 
@@ -371,6 +377,27 @@
 ;; need for closurebuilder. cljs dependencies will be compiled as
 ;; needed.
 
+(defn find-url
+ "Given a string, returns a URL. Attempts to resolve as a classpath-relative
+ path, then as a path relative to the working directory or a URL string"
+ [path-or-url]
+ (or (io/resource path-or-url)
+ (try (io/as-url path-or-url)
+ (catch java.net.MalformedURLException e
+ false))
+ (io/as-url (io/as-file path-or-url))))
+
+(defn load-foreign-library*
+ "Given a library spec (a map containing the keys :file
+ and :provides), returns a map containing :provides, :requires, :file
+ and :url"
+ [lib-spec]
+ (merge lib-spec {:foreign true
+ :requires nil
+ :url (find-url (:file lib-spec))}))
+
+(def load-foreign-library (memoize load-foreign-library*))
+
 (defn load-library*
  "Given a path to a JavaScript library, which is a directory
  containing Javascript files, return a list of maps
@@ -386,15 +413,22 @@
 
 (def load-library (memoize load-library*))
 
-(defn library-dependencies [{:keys [libs]}]
- (mapcat load-library libs))
+(defn library-dependencies [{:keys [libs foreign-libs]}]
+ (concat
+ (mapcat load-library libs)
+ (map load-foreign-library foreign-libs)))
 
 (comment
  ;; load one library
  (load-library* "closure/library/third_party/closure")
  ;; load all library dependencies
  (library-dependencies {:libs ["closure/library/third_party/closure"]})
- )
+ (library-dependencies {:foreign-libs [{:file "http:https://example.com/remote.js"
+ :provides ["my.example"]}]})
+ (library-dependencies {:foreign-libs [{:file "local/file.js"
+ :provides ["my.example"]}]})
+ (library-dependencies {:foreign-libs [{:file "cljs/nodejs_externs.js"
+ :provides ["my.example"]}]}))
 
 (defn goog-dependencies*
  "Create an index of Google dependencies by namespace and file name."
@@ -414,6 +448,7 @@
 
 (def goog-dependencies (memoize goog-dependencies*))
 
+
 (defn js-dependency-index
  "Returns the index for all JavaScript dependencies. Lookup by
  namespace or file name."
@@ -501,7 +536,8 @@
  (let [requires (mapcat -requires inputs)
  required-cljs (cljs-dependencies opts requires)
  required-js (js-dependencies opts (set (concat (mapcat -requires required-cljs) requires)))]
- (concat (map #(-> (javascript-file (or (:url %) (io/resource (:file %)))
+ (concat (map #(-> (javascript-file (:foreign %)
+ (or (:url %) (io/resource (:file %)))
  (:provides %)
  (:requires %))
  (assoc :group (:group %))) required-js)
@@ -520,10 +556,16 @@
  (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 (to-url "samples/hello/src/hello/core.cljs")
- ["hello.core"]
- ["goog.array"]))
+ (add-dependencies {} (javascript-file false
+ (to-url "samples/hello/src/hello/core.cljs")
+ ["hello.core"]
+ ["goog.array"]))
  )
 
 ;; Optimize
@@ -539,9 +581,18 @@
 
 (defmethod javascript-name JavaScriptFile [js] (javascript-name (-url js)))
 
+(defn build-provides
+ "Given a vector of provides, builds required goog.provide statements"
+ [provides]
+ (apply str (map #(str "goog.provide('" % "');\n") provides)))
+
+
 (defmethod js-source-file JavaScriptFile [_ js]
- (when-let [url (-url js)]
- (js-source-file (javascript-name url) (io/input-stream url))))
+ (when-let [url (-url js)]
+ (js-source-file (javascript-name url)
+ (if (-foreign? js)
+ (str (build-provides (-provides js)) (slurp url))
+ (io/input-stream url)))))
 
 (defn optimize
  "Use the Closure Compiler to optimize one or more JavaScript files."