clementine 0.0.1

data/vendor/assets/src/cljs/clojure/browser/event.cljs

@@ -0,0 +1,100 @@
+;;  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 ^{:doc "This namespace contains functions to work with browser
+events.  It is based on the Google Closure Library event system."
+      :author "Bobby Calderwood"}
+  clojure.browser.event
+  (:require [goog.events :as events]
+            [goog.events.EventTarget :as gevent-target]
+            [goog.events.EventType   :as gevent-type]))
+
+(defprotocol EventType
+  (event-types [this]))
+
+(extend-protocol EventType
+
+  goog.events.EventTarget
+  (event-types
+    [this]
+    (into {}
+          (map
+           (fn [[k v]]
+             [(keyword (. k (toLowerCase)))
+              v])
+           (merge
+            (js->clj goog.events.EventType)))))
+
+  js/Element
+  (event-types
+    [this]
+    (into {}
+          (map
+           (fn [[k v]]
+             [(keyword (. k (toLowerCase)))
+              v])
+           (merge
+            (js->clj goog.events.EventType))))))
+
+(defn listen
+  ([src type fn]
+     (listen src type fn false))
+  ([src type fn capture?]
+     (goog.events/listen src
+                         (get (event-types src) type type)
+                         fn
+                         capture?)))
+
+(defn listen-once
+  ([src type fn]
+     (listen-once src type fn false))
+  ([src type fn capture?]
+     (goog.events/listenOnce src
+                             (get (event-types src) type type)
+                             fn
+                             capture?)))
+
+(defn unlisten
+  ([src type fn]
+     (unlisten src type fn false))
+  ([src type fn capture?]
+     (goog.events/unlisten src
+                           (get (event-types src) type type)
+                           fn
+                           capture?)))
+
+(defn unlisten-by-key
+  [key]
+  (goog.events/unlistenByKey key))
+
+(defn dispatch-event
+  [src event]
+  (goog.events/dispatchEvent src event))
+
+(defn expose [e]
+  (goog.events/expose e))
+
+(defn fire-listeners
+  [obj type capture event])
+
+(defn total-listener-count []
+  (goog.events/getTotalListenerCount))
+
+;; TODO
+(defn get-listener [src type listener opt_capt opt_handler]); ⇒ ?Listener
+(defn all-listeners [obj type capture]); ⇒ Array.<Listener>
+
+(defn unique-event-id [event-type]); ⇒ string
+
+(defn has-listener [obj opt_type opt_capture]); ⇒ boolean
+;; TODO? (defn listen-with-wrapper [src wrapper listener opt_capt opt_handler])
+;; TODO? (defn protect-browser-event-entry-point [errorHandler])
+
+(defn remove-all [opt_obj opt_type opt_capt]); ⇒ number
+;; TODO? (defn unlisten-with-wrapper [src wrapper listener opt_capt opt_handler])
+

data/vendor/assets/src/cljs/clojure/browser/net.cljs

@@ -0,0 +1,182 @@
+;;  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 ^{:doc "Network communication library, wrapping goog.net.
+Includes a common API over XhrIo, CrossPageChannel, and Websockets."
+      :author "Bobby Calderwood and Alex Redington"}
+  clojure.browser.net
+  (:require [clojure.browser.event :as event]
+            [goog.net.XhrIo :as gxhrio]
+            [goog.net.EventType :as gnet-event-type]
+            [goog.net.xpc.CfgFields :as gxpc-config-fields]
+            [goog.net.xpc.CrossPageChannel :as xpc]
+            #_[goog.net.WebSocket :as gwebsocket]
+            [goog.json :as gjson]))
+
+(def *timeout* 10000)
+
+(def event-types
+  (into {}
+        (map
+         (fn [[k v]]
+           [(keyword (. k (toLowerCase)))
+            v])
+         (merge
+          (js->clj goog.net.EventType)))))
+
+(defprotocol IConnection
+  (connect
+    [this]
+    [this opt1]
+    [this opt1 opt2]
+    [this opt1 opt2 opt3])
+  (transmit
+    [this opt]
+    [this opt opt2]
+    [this opt opt2 opt3]
+    [this opt opt2 opt3 opt4]
+    [this opt opt2 opt3 opt4 opt5])
+  (close [this]))
+
+(extend-type goog.net.XhrIo
+
+  IConnection
+  (transmit
+    ([this uri]
+       (transmit this uri "GET"  nil nil *timeout*))
+    ([this uri method]
+       (transmit this uri method nil nil *timeout*))
+    ([this uri method content]
+       (transmit this uri method content nil *timeout*))
+    ([this uri method content headers]
+       (transmit this uri method content headers *timeout*))
+    ([this uri method content headers timeout]
+       (.setTimeoutInterval this timeout)
+       (.send this uri method content headers)))
+
+
+  event/EventType
+  (event-types [this]
+    (into {}
+          (map
+           (fn [[k v]]
+             [(keyword (. k (toLowerCase)))
+              v])
+           (merge
+            (js->clj goog.net.EventType))))))
+
+;; TODO jQuery/sinatra/RestClient style API: (get [uri]), (post [uri payload]), (put [uri payload]), (delete [uri])
+
+(def xpc-config-fields
+  (into {}
+        (map
+         (fn [[k v]]
+           [(keyword (. k (toLowerCase)))
+            v])
+         (js->clj goog.net.xpc.CfgFields))))
+
+(defn xhr-connection
+  "Returns an XhrIo connection"
+  []
+  (goog.net.XhrIo.))
+
+(defprotocol ICrossPageChannel
+  (register-service [this service-name fn] [this service-name fn encode-json?]))
+
+(extend-type goog.net.xpc.CrossPageChannel
+
+  ICrossPageChannel
+  (register-service
+    ([this service-name fn]
+       (register-service this service-name fn false))
+    ([this service-name fn encode-json?]
+       (.registerService this (name service-name) fn encode-json?)))
+
+  IConnection
+  (connect
+    ([this]
+       (connect this nil))
+    ([this on-connect-fn]
+       (.connect this on-connect-fn))
+    ([this on-connect-fn config-iframe-fn]
+       (connect this on-connect-fn config-iframe-fn (.body js/document)))
+    ([this on-connect-fn config-iframe-fn iframe-parent]
+       (.createPeerIframe this iframe-parent config-iframe-fn)
+       (.connect this on-connect-fn)))
+
+  (transmit [this service-name payload]
+    (.send this (name service-name) payload))
+
+  (close [this]
+    (.close this ())))
+
+(defn xpc-connection
+  "When passed with a config hash-map, returns a parent
+  CrossPageChannel object. Keys in the config hash map are downcased
+  versions of the goog.net.xpc.CfgFields enum keys,
+  e.g. goog.net.xpc.CfgFields.PEER_URI becomes :peer_uri in the config
+  hash.
+
+  When passed with no args, creates a child CrossPageChannel object,
+  and the config is automatically taken from the URL param 'xpc', as
+  per the CrossPageChannel API."
+  ([]
+     (when-let [config (.getParameterValue
+                        (goog.Uri. (.href (.location js/window)))
+                        "xpc")]
+       (goog.net.xpc.CrossPageChannel. (gjson/parse config))))
+  ([config]
+     (goog.net.xpc.CrossPageChannel.
+      (.strobj (reduce (fn [sum [k v]]
+                         (when-let [field (get xpc-config-fields k)]
+                           (assoc sum field v)))
+                       {}
+                       config)))))
+
+;; WebSocket is not supported in the 3/23/11 release of Google
+;; Closure, but will be included in the next release.
+
+#_(defprotocol IWebSocket
+    (open? [this]))
+
+#_(extend-type goog.net.WebSocket
+
+  IWebSocket
+  (open? [this]
+    (.isOpen this ()))
+
+  IConnection
+  (connect
+    ([this url]
+       (connect this url nil))
+    ([this url protocol]
+       (.open this url protocol)))
+
+  (transmit [this message]
+    (.send this message))
+
+  (close [this]
+    (.close this ()))
+
+  event/EventType
+  (event-types [this]
+    (into {}
+          (map
+           (fn [[k v]]
+             [(keyword (. k (toLowerCase)))
+              v])
+           (merge
+            (js->clj goog.net.WebSocket/EventType))))))
+
+#_(defn websocket-connection
+  ([]
+     (websocket-connection nil nil))
+  ([auto-reconnect?]
+     (websocket-connection auto-reconnect? nil))
+  ([auto-reconnect? next-reconnect-fn]
+     (goog.net.WebSocket. auto-reconnect? next-reconnect-fn)))

data/vendor/assets/src/cljs/clojure/browser/repl.cljs

@@ -0,0 +1,109 @@
+;;  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 ^{:doc "Receive - Eval - Print - Loop
+
+  Receive a block of JS (presumably generated by a ClojureScript compiler)
+  Evaluate it naively
+  Print the result of evaluation to a string
+  Send the resulting string back to the server Loop!"
+
+      :author "Bobby Calderwood and Alex Redington"}
+  clojure.browser.repl
+  (:require [clojure.browser.net   :as net]
+            [clojure.browser.event :as event]))
+
+(def xpc-connection (atom nil))
+
+(defn repl-print [data]
+  (if-let [conn @xpc-connection]
+    (net/transmit conn :print (pr-str data))))
+
+(defn evaluate-javascript
+  "Process a single block of JavaScript received from the server"
+  [conn block]
+  (let [result (try {:status :success :value (str (js* "eval(~{block})"))}
+                    (catch js/Error e
+                      {:status :exception :value (pr-str e)
+                       :stacktrace (if (.hasOwnProperty e "stack")
+                                     (.stack e)
+                                     "No stacktrace available.")}))]
+    (pr-str result)))
+
+(defn send-result [connection url data]
+  (net/transmit connection url "POST" data nil 0))
+
+(defn send-print
+  "Send data to be printed in the REPL. If there is an error, try again
+  up to 10 times."
+  ([url data]
+     (send-print url data 0))
+  ([url data n]
+     (let [conn (net/xhr-connection)]
+       (event/listen conn :error
+                     (fn [_]
+                       (if (< n 10)
+                         (send-print url data (inc n))
+                         (.log js/console (str "Could not send " data " after " n " attempts.")))))
+       (net/transmit conn url "POST" data nil 0))))
+
+(def order (atom 0))
+
+(defn wrap-message [t data]
+  (pr-str {:type t :content data :order (swap! order inc)}))
+
+(defn start-evaluator
+  "Start the REPL server connection."
+  [url]
+  (if-let [repl-connection (net/xpc-connection)]
+    (let [connection (net/xhr-connection)]
+      (event/listen connection
+                    :success
+                    (fn [e]
+                      (net/transmit
+                       repl-connection
+                       :evaluate-javascript
+                       (.getResponseText e/currentTarget
+                                         ()))))
+
+      (net/register-service repl-connection
+                            :send-result
+                            (fn [data]
+                              (send-result connection url (wrap-message :result data))))
+
+      (net/register-service repl-connection
+                            :print
+                            (fn [data]
+                              (send-print url (wrap-message :print data))))
+      
+      (net/connect repl-connection
+                   (constantly nil))
+
+      (js/setTimeout #(send-result connection url (wrap-message :ready "ready")) 50))
+    (js/alert "No 'xpc' param provided to child iframe.")))
+
+(defn connect
+  "Connects to a REPL server from an HTML document. After the
+  connection is made, the REPL will evaluate forms in the context of
+  the document that called this function."
+  [repl-server-url]
+  (let [repl-connection (net/xpc-connection
+                         {:peer_uri repl-server-url})]
+    (swap! xpc-connection (constantly repl-connection))
+    (net/register-service repl-connection
+                          :evaluate-javascript
+                          (fn [js]
+                            (net/transmit
+                             repl-connection
+                             :send-result
+                             (evaluate-javascript repl-connection js))))
+    (net/connect repl-connection
+                 (constantly nil)
+                 (fn [iframe]
+                   (set! iframe.style.display
+                         "none")))))

data/vendor/assets/src/cljs/clojure/set.cljs

@@ -0,0 +1,162 @@
+;   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 ^{:doc "Set operations such as union/intersection."
+       :author "Rich Hickey"}
+       clojure.set)
+
+(defn- bubble-max-key [k coll]
+  "Move a maximal element of coll according to fn k (which returns a number) 
+   to the front of coll."
+  (let [max (apply max-key k coll)]
+    (cons max (remove #(identical? max %) coll))))
+
+(defn union
+  "Return a set that is the union of the input sets"
+  ([] #{})
+  ([s1] s1)
+  ([s1 s2]
+     (if (< (count s1) (count s2))
+       (reduce conj s2 s1)
+       (reduce conj s1 s2)))
+  ([s1 s2 & sets]
+     (let [bubbled-sets (bubble-max-key count (conj sets s2 s1))]
+       (reduce into (first bubbled-sets) (rest bubbled-sets)))))
+
+(defn intersection
+  "Return a set that is the intersection of the input sets"
+  ([s1] s1)
+  ([s1 s2]
+     (if (< (count s2) (count s1))
+       (recur s2 s1)
+       (reduce (fn [result item]
+                   (if (contains? s2 item)
+		     result
+                     (disj result item)))
+	       s1 s1)))
+  ([s1 s2 & sets] 
+     (let [bubbled-sets (bubble-max-key #(- (count %)) (conj sets s2 s1))]
+       (reduce intersection (first bubbled-sets) (rest bubbled-sets)))))
+
+(defn difference
+  "Return a set that is the first set without elements of the remaining sets"
+  ([s1] s1)
+  ([s1 s2] 
+     (if (< (count s1) (count s2))
+       (reduce (fn [result item] 
+                   (if (contains? s2 item) 
+                     (disj result item) 
+                     result))
+               s1 s1)
+       (reduce disj s1 s2)))
+  ([s1 s2 & sets] 
+     (reduce difference s1 (conj sets s2))))
+
+
+(defn select
+  "Returns a set of the elements for which pred is true"
+  [pred xset]
+    (reduce (fn [s k] (if (pred k) s (disj s k)))
+            xset xset))
+
+(defn project
+  "Returns a rel of the elements of xrel with only the keys in ks"
+  [xrel ks]
+    (set (map #(select-keys % ks) xrel)))
+
+(defn rename-keys
+  "Returns the map with the keys in kmap renamed to the vals in kmap"
+  [map kmap]
+    (reduce 
+     (fn [m [old new]]
+       (if (and (not= old new)
+                (contains? m old))
+         (-> m (assoc new (get m old)) (dissoc old))
+         m)) 
+     map kmap))
+
+(defn rename
+  "Returns a rel of the maps in xrel with the keys in kmap renamed to the vals in kmap"
+  [xrel kmap]
+    (set (map #(rename-keys % kmap) xrel)))
+
+(defn index
+  "Returns a map of the distinct values of ks in the xrel mapped to a
+  set of the maps in xrel with the corresponding values of ks."
+  [xrel ks]
+    (reduce
+     (fn [m x]
+       (let [ik (select-keys x ks)]
+         (assoc m ik (conj (get m ik #{}) x))))
+     {} xrel))
+   
+(defn map-invert
+  "Returns the map with the vals mapped to the keys."
+  [m] (reduce (fn [m [k v]] (assoc m v k)) {} m))
+
+(defn join
+  "When passed 2 rels, returns the rel corresponding to the natural
+  join. When passed an additional keymap, joins on the corresponding
+  keys."
+  ([xrel yrel] ;natural join
+   (if (and (seq xrel) (seq yrel))
+     (let [ks (intersection (set (keys (first xrel))) (set (keys (first yrel))))
+           [r s] (if (<= (count xrel) (count yrel))
+                   [xrel yrel]
+                   [yrel xrel])
+           idx (index r ks)]
+       (reduce (fn [ret x]
+                 (let [found (idx (select-keys x ks))]
+                   (if found
+                     (reduce #(conj %1 (merge %2 x)) ret found)
+                     ret)))
+               #{} s))
+     #{}))
+  ([xrel yrel km] ;arbitrary key mapping
+   (let [[r s k] (if (<= (count xrel) (count yrel))
+                   [xrel yrel (map-invert km)]
+                   [yrel xrel km])
+         idx (index r (vals k))]
+     (reduce (fn [ret x]
+               (let [found (idx (rename-keys (select-keys x (keys k)) k))]
+                 (if found
+                   (reduce #(conj %1 (merge %2 x)) ret found)
+                   ret)))
+             #{} s))))
+
+(defn subset? 
+  "Is set1 a subset of set2?"
+  [set1 set2]
+  (and (<= (count set1) (count set2))
+       (every? #(contains? set2 %) set1)))
+
+(defn superset? 
+  "Is set1 a superset of set2?"
+  [set1 set2]
+  (and (>= (count set1) (count set2))
+       (every? #(contains? set1 %) set2)))
+
+(comment
+(refer 'set)
+(def xs #{{:a 11 :b 1 :c 1 :d 4}
+         {:a 2 :b 12 :c 2 :d 6}
+         {:a 3 :b 3 :c 3 :d 8 :f 42}})
+
+(def ys #{{:a 11 :b 11 :c 11 :e 5}
+         {:a 12 :b 11 :c 12 :e 3}
+         {:a 3 :b 3 :c 3 :e 7 }})
+
+(join xs ys)
+(join xs (rename ys {:b :yb :c :yc}) {:a :a})
+
+(union #{:a :b :c} #{:c :d :e })
+(difference #{:a :b :c} #{:c :d :e})
+(intersection #{:a :b :c} #{:c :d :e})
+
+(index ys [:b]))
+