clementine 0.0.1

data/vendor/assets/src/cljs/cljs/nodejs.cljs

@@ -0,0 +1,11 @@
+; Projects compiled with :target :nodejs can 'require' this namespace
+; to get the nodejs globals loaded into cljs.nodejs and get
+; ClojureScript's 'print' set up correctly.
+(ns cljs.nodejs)
+
+; Define namespaced references to Node's externed globals:
+(def require (js* "require"))
+(def process (js* "process"))
+
+; Have ClojureScript print using Node's sys.print function
+(set! cljs.core/string-print (.print (require "sys")))

data/vendor/assets/src/cljs/cljs/nodejs_externs.js

@@ -0,0 +1,2 @@
+function require(){}
+function process(){}

data/vendor/assets/src/cljs/cljs/nodejscli.cljs

@@ -0,0 +1,9 @@
+; Projects compiled with :target :nodejs have this file appended.  Its
+; job is to make sure cljs.nodejs is loaded and that the *main-cli-fn*
+; is called with the script's command-line arguments.
+(ns cljs.nodejscli
+  (:require [cljs.nodejs :as nodejs]))
+
+; Call the user's main function
+(apply cljs.core/*main-cli-fn* (drop 2 (.argv nodejs/process)))
+

data/vendor/assets/src/cljs/cljs/reader.cljs

@@ -0,0 +1,360 @@
+;   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.reader
+  (:require [goog.string :as gstring]))
+
+(defprotocol PushbackReader
+  (read-char [reader] "Returns the next char from the Reader,
+nil if the end of stream has been reached")
+  (unread [reader ch] "Push back a single character on to the stream"))
+
+; Using two atoms is less idomatic, but saves the repeat overhead of map creation
+(deftype StringPushbackReader [s index-atom buffer-atom]
+  PushbackReader
+  (read-char [reader]
+             (if (empty? @buffer-atom)
+               (let [idx @index-atom]
+                 (swap! index-atom inc)
+                 (nth s idx))
+               (let [buf @buffer-atom]
+                 (swap! buffer-atom rest)
+                 (first buf))))
+  (unread [reader ch] (swap! buffer-atom #(cons ch %))))
+
+(defn push-back-reader [s]
+  "Creates a StringPushbackReader from a given string"
+  (StringPushbackReader. s (atom 0) (atom nil)))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; predicates
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defn- whitespace?
+  "Checks whether a given character is whitespace"
+  [ch]
+  (or (gstring/isBreakingWhitespace ch) (= \, ch)))
+
+(defn- numeric?
+  "Checks whether a given character is numeric"
+  [ch]
+  (gstring/isNumeric ch))
+
+(defn- comment-prefix?
+  "Checks whether the character begins a comment."
+  [ch]
+  (= \; ch))
+
+(defn- number-literal?
+  "Checks whether the reader is at the start of a number literal"
+  [reader initch]
+  (or (numeric? initch)
+      (and (or (= \+ initch) (= \- initch))
+           (numeric? (let [next-ch (read-char reader)]
+                       (unread reader next-ch)
+                       next-ch)))))
+
+(declare read macros dispatch-macros)
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; read helpers
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+; later will do e.g. line numbers...
+(defn reader-error
+  [rdr & msg]
+  (throw (apply str msg)))
+
+(defn macro-terminating? [ch]
+  (and (not= ch "#") (not= ch \') (not= ch ":") (contains? macros ch)))
+
+(defn read-token
+  [rdr initch]
+  (loop [sb (gstring/StringBuffer. initch)
+         ch (read-char rdr)]
+    (if (or (nil? ch)
+            (whitespace? ch)
+            (macro-terminating? ch))
+      (do (unread rdr ch) (. sb (toString)))
+      (recur (do (.append sb ch) sb) (read-char rdr)))))
+
+(defn skip-line
+  "Advances the reader to the end of a line. Returns the reader"
+  [reader _]
+  (loop []
+    (let [ch (read-char reader)]
+      (if (or (= ch \n) (= ch \r) (nil? ch))
+        reader
+        (recur)))))
+
+(def int-pattern (re-pattern "([-+]?)(?:(0)|([1-9][0-9]*)|0[xX]([0-9A-Fa-f]+)|0([0-7]+)|([1-9][0-9]?)[rR]([0-9A-Za-z]+)|0[0-9]+)(N)?"))
+(def ratio-pattern (re-pattern "([-+]?[0-9]+)/([0-9]+)"))
+(def float-pattern (re-pattern "([-+]?[0-9]+(\\.[0-9]*)?([eE][-+]?[0-9]+)?)(M)?"))
+(def symbol-pattern (re-pattern "[:]?([^0-9/].*/)?([^0-9/][^/]*)"))
+
+(defn- match-int
+  [s]
+  (let [groups (re-find int-pattern s)]
+    (if (nth groups 2)
+      0
+      (let [negate (if (= "-" (nth groups 1)) -1 1) 
+            [n radix] (cond
+                       (nth groups 3) [(nth groups 3) 10]
+                       (nth groups 4) [(nth groups 4) 16]
+                       (nth groups 5) [(nth groups 5) 8]
+                       (nth groups 7) [(nth groups 7) (js/parseInt (nth groups 7))] 
+                       :default [nil nil])]
+        (if (nil? n)
+          nil
+          (* negate (js/parseInt n radix)))))))
+
+
+(defn- match-ratio
+  [s]
+  (let [groups (re-find ratio-pattern s)
+        numinator (nth groups 1)
+        denominator (nth groups 2)]
+    (/ (js/parseInt numinator) (js/parseInt denominator))))
+
+(defn- match-float
+  [s]
+  (js/parseFloat s))
+
+(defn- match-number
+  [s]
+  (cond
+   (re-matches int-pattern s) (match-int s)
+   (re-matches ratio-pattern s) (match-ratio s)
+   (re-matches float-pattern s) (match-float s)))
+
+(def escape-char-map {\t "\t"
+                      \r "\r"
+                      \n "\n"
+                      \\ \\
+                      \" \"
+                      \b "\b"
+                      \f "\f"})
+
+(defn read-unicode-char
+  [reader initch]
+  (reader-error reader "Unicode characters not supported by reader (yet)"))
+
+(defn escape-char
+  [buffer reader]
+  (let [ch (read-char reader)
+        mapresult (get escape-char-map ch)]
+    (if mapresult
+      mapresult
+      (if (or (= \u ch) (numeric? ch))
+        (read-unicode-char reader ch)
+        (reader-error reader "Unsupported escape charater: \\" ch)))))
+
+(defn read-past
+  "Read until first character that doesn't match pred, returning
+   char."
+  [pred rdr]
+  (loop [ch (read-char rdr)]
+    (if (pred ch)
+      (recur (read-char rdr))
+      ch)))
+
+(defn read-delimited-list
+  [delim rdr recursive?]
+  (loop [a []]
+    (let [ch (read-past whitespace? rdr)]
+      (when-not ch (reader-error rdr "EOF"))
+      (if (= delim ch)
+        a
+        (if-let [macrofn (get macros ch)]
+          (let [mret (macrofn rdr ch)]
+            (recur (if (= mret rdr) a (conj a mret))))
+          (do
+            (unread rdr ch)
+            (let [o (read rdr true nil recursive?)]
+              (recur (if (= o rdr) a (conj a o))))))))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; data structure readers
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defn not-implemented
+  [rdr ch]
+  (reader-error rdr "Reader for " ch " not implemented yet"))
+
+(defn read-dispatch
+  [rdr _]
+  (let [ch (read-char rdr)
+        dm (get dispatch-macros ch)]
+    (if dm
+      (dm rdr _)
+      (reader-error rdr "No dispatch macro for " ch))))
+
+(defn read-unmatched-delimiter
+  [rdr ch]
+  (reader-error rdr "Unmached delimiter " ch))
+
+(defn read-list
+  [rdr _]
+  (apply list (read-delimited-list ")" rdr true)))
+
+(def read-comment skip-line)
+
+(defn read-vector
+  [rdr _]
+  (read-delimited-list "]" rdr true))
+
+(defn read-map
+  [rdr _]
+  (let [l (read-delimited-list "}" rdr true)]
+    (when (odd? (count l))
+      (reader-error rdr "Map literal must contain an even number of forms"))
+    (apply hash-map l)))
+
+(defn read-number
+  [reader initch]
+  (loop [buffer (gstring/StringBuffer. initch)
+         ch (read-char reader)]
+    (if (or (nil? ch) (whitespace? ch) (contains? macros ch))
+      (do
+        (unread reader ch)
+        (let [s (. buffer (toString))]
+          (or (match-number s)
+              (reader-error reader "Invalid number format [" s "]"))))
+      (recur (do (.append buffer ch) buffer) (read-char reader)))))
+
+(defn read-string
+  [reader _]
+  (loop [buffer (gstring/StringBuffer.)
+         ch (read-char reader)]
+    (cond
+     (nil? ch) (reader-error reader "EOF while reading string")
+     (= "\\" ch) (recur (do (.append buffer (escape-char buffer reader)) buffer)
+                        (read-char reader))
+     (= \" ch) (. buffer (toString))
+     :default (recur (do (.append buffer ch) buffer) (read-char reader)))))
+
+(def special-symbols
+  {"nil" nil
+   "true" true
+   "false" false})
+
+(defn read-symbol
+  [reader initch]
+  (let [token (read-token reader initch)]
+    (if (gstring/contains token "/")
+      (symbol (subs token 0 (.indexOf token "/"))
+              (subs (inc (.indexOf token "/")) (.length token)))
+      (get special-symbols token (symbol token)))))
+
+(defn read-keyword
+  [reader initch]
+  (let [token (read-token reader (read-char reader))
+        [token ns name] (re-matches symbol-pattern token)]
+    (if (or (and (not (undefined? ns))
+                 (identical? (. ns (substring (- (.length ns) 2) (.length ns))) ":/"))
+            (identical? (aget name (dec (.length name))) ":")
+            (not (== (.indexOf token "::" 1) -1)))
+      (reader-error reader "Invalid token: " token)
+      (if (not (undefined? ns))
+        (keyword (.substring ns 0 (.indexOf ns "/")) name)
+        (keyword token)))))
+
+(defn desugar-meta
+  [f]
+  (cond
+   (symbol? f) {:tag f}
+   (string? f) {:tag f}
+   (keyword? f) {f true}
+   :else f))
+
+(defn wrapping-reader
+  [sym]
+  (fn [rdr _]
+    (list sym (read rdr true nil true))))
+
+(defn throwing-reader
+  [msg]
+  (fn [rdr _]
+    (reader-error rdr msg)))
+
+(defn read-meta
+  [rdr _]
+  (let [m (desugar-meta (read rdr true nil true))]
+    (when-not (map? m)
+      (reader-error rdr "Metadata must be Symbol,Keyword,String or Map"))
+    (let [o (read rdr true nil true)]
+      (if (satisfies? IWithMeta o)
+        (with-meta o (merge (meta o) m))
+        (reader-error rdr "Metadata can only be applied to IWithMetas")))))
+
+(defn read-set
+  [rdr _]
+  (set (read-delimited-list "}" rdr true)))
+
+(defn read-regex
+  [rdr ch]
+  (-> (read-string rdr ch) re-pattern))
+
+(defn read-discard
+  [rdr _]
+  (read rdr true nil true)
+  rdr)
+
+(def macros
+     { \" read-string
+       \: read-keyword
+       \; not-implemented ;; never hit this
+       \' (wrapping-reader 'quote)
+       \@ (wrapping-reader 'deref)
+       \^ read-meta
+       \` not-implemented
+       \~ not-implemented
+       \( read-list
+       \) read-unmatched-delimiter
+       \[ read-vector
+       \] read-unmatched-delimiter
+       \{ read-map
+       \} read-unmatched-delimiter
+       \\ read-char
+       \% not-implemented
+       \# read-dispatch
+       })
+
+;; omitted by design: var reader, eval reader
+(def dispatch-macros
+  {"{" read-set
+   "<" (throwing-reader "Unreadable form")
+   "\"" read-regex
+   "!" read-comment
+   "_" read-discard})
+
+(defn read
+  "Reads the first object from a PushbackReader. Returns the object read.
+   If EOF, throws if eof-is-error is true. Otherwise returns sentinel."
+  [reader eof-is-error sentinel is-recursive]
+  (let [ch (read-char reader)]
+    (cond
+     (nil? ch) (if eof-is-error (reader-error reader "EOF") sentinel)
+     (whitespace? ch) (recur reader eof-is-error sentinel is-recursive)
+     (comment-prefix? ch) (recur (read-comment reader ch) eof-is-error sentinel is-recursive)
+     :else (let [res
+                 (cond
+                  (macros ch) ((macros ch) reader ch)
+                  (number-literal? reader ch) (read-number reader ch)
+                  :else (read-symbol reader ch))]
+     (if (= res reader)
+       (recur reader eof-is-error sentinel is-recursive)
+       res)))))
+
+(defn read-string
+  "Reads one object from the string s"
+  [s]
+  (let [r (push-back-reader s)]
+    (read r true nil false)))
+
+  

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

@@ -0,0 +1,106 @@
+;;  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 clojure.browser.dom
+  (:require [goog.dom :as gdom]))
+
+(defn append [parent & children]
+  (apply gdom/append parent children)
+  parent)
+
+(defprotocol DOMBuilder
+  (-element [this] [this attrs-or-children] [this attrs children]))
+
+(defn log [& args]
+  (.log js/console (apply pr-str args)))
+
+(defn log-obj [obj]
+  (.log js/console obj))
+
+(extend-protocol DOMBuilder
+
+  string
+  (-element
+    ([this]
+       (log "string (-element " this ")")
+       (cond (keyword? this) (gdom/createElement  (name this))
+             :else           (gdom/createTextNode (name this))))
+
+    ([this attrs-or-children]
+       (log "string (-element " this " " attrs-or-children ")")
+       (let [attrs (first attrs-or-children)]
+         (if (map? attrs)
+           (-element this attrs (rest attrs-or-children))
+           (-element this nil attrs-or-children))))
+
+    ([this attrs children]
+       (log "string (-element " this " " attrs " " children ")")
+       (let [str-attrs (if (and (map? attrs) (seq attrs))
+                         (.strobj (reduce (fn [m [k v]]
+                                            (log "m = " m)
+                                            (log "k = " k)
+                                            (log "v = " v)
+                                            (when (or (keyword? k)
+                                                      (string? k))
+                                              (assoc m (name k) v)))
+                                          {}
+                                          attrs))
+                         nil)]
+         (log-obj str-attrs)
+         (if (seq children)
+           (apply gdom/createDom
+                  (name this)
+                  str-attrs
+                  (map -element children))
+           (gdom/createDom (name this)
+                          str-attrs)))))
+
+  Vector
+  (-element
+    [this]
+    (log "Vector (-element " this ")")
+    (let [tag      (first this)
+          attrs    (second this)
+          children (drop 2 this)]
+      (if (map? attrs)
+        (-element tag attrs children)
+        (-element tag nil (rest this)))))
+
+  js/Element
+  (-element [this]
+    (log "js/Element (-element " this ")")
+    this))
+
+(defn element
+  ([tag-or-text]
+     (log "(element " tag-or-text ")")
+     (-element tag-or-text))
+  ([tag & children]
+     (log "(element " tag " " children ")")
+     (let [attrs (first children)]
+       (if (map? attrs)
+         (-element tag attrs (rest children))
+         (-element tag nil children)))))
+
+(defn remove-children
+  "Remove all children from the element with the passed id."
+  [id]
+  (let [parent (gdom/getElement (name id))]
+    (do (gdom/removeChildren parent))))
+
+(defn get-element [id]
+  (gdom/getElement (name id)))
+
+(defn html->dom [s]
+  (gdom/htmlToDocumentFragment s))
+
+(defn insert-at [parent child index]
+  (gdom/insertChildAt parent child index))
+
+;; TODO CSS class manipulation
+;; TODO Query syntax