clementine 0.0.1 → 0.0.2

data/{vendor/assets → ext/clojure-clojurescript-bef56a7}/src/cljs/clojure/browser/dom.cljs

@@ -7,7 +7,8 @@
 ;;  You must not remove this notice, or any other, from this software.
 
 (ns clojure.browser.dom
-  (:require [goog.dom :as gdom]))
+  (:require [goog.dom :as gdom]
+            [goog.object :as gobject]))
 
 (defn append [parent & children]
   (apply gdom/append parent children)
@@ -41,15 +42,16 @@
     ([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))
+                         (reduce (fn [o [k v]]
+                                   (let [o (if (nil? o) (js-obj) o)]
+                                     (log "o = " o)
+                                     (log "k = " k)
+                                     (log "v = " v)
+                                     (when (or (keyword? k)
+                                               (string? k))
+                                       (doto o (aset (name k) v)))))
+                                 (js-obj)
+                                 attrs)
                          nil)]
          (log-obj str-attrs)
          (if (seq children)
@@ -58,12 +60,12 @@
                   str-attrs
                   (map -element children))
            (gdom/createDom (name this)
-                          str-attrs)))))
+                           str-attrs)))))
 
-  Vector
+  PersistentVector
   (-element
     [this]
-    (log "Vector (-element " this ")")
+    (log "PersistentVector (-element " this ")")
     (let [tag      (first this)
           attrs    (second this)
           children (drop 2 this)]
@@ -102,5 +104,49 @@
 (defn insert-at [parent child index]
   (gdom/insertChildAt parent child index))
 
+(defn ensure-element
+  "Coerce the argument to a dom element if possible."
+  [e]
+  (cond (keyword? e) (get-element e)
+        (string? e) (html->dom e)
+        :else e))
+
+(defn replace-node
+  "Replace old-node with new-node. old-node can be an element or a
+   keyword which is the id of the node to replace.  new-node can be an
+   element or an html string."
+  [old-node new-node]
+  (let [old-node (ensure-element old-node)
+        new-node (ensure-element new-node)]
+    (gdom/replaceNode new-node old-node)
+    new-node))
+
+(defn set-text
+  "Set the text content for the passed element returning the
+  element. If a keyword is passed in the place of e, the element with
+  that id will be used and returned."
+  [e s]
+  (gdom/setTextContent (ensure-element e) s))
+
+(defn get-value
+  "Get the value of an element."
+  [e]
+  (.-value (ensure-element e)))
+
+(defn set-properties
+  "Set properties on an element"
+  [e m]
+  (gdom/setProperties (ensure-element e)
+                      (apply gobject/create (interleave (keys m) (vals m)))))
+
+(defn set-value
+  "Set the value property for an element."
+  [e v]
+  (set-properties e {"value" v}))
+
+(defn click-element
+  [e]
+  (.click (ensure-element e) ()))
+
 ;; TODO CSS class manipulation
 ;; TODO Query syntax

data/{vendor/assets → ext/clojure-clojurescript-bef56a7}/src/cljs/clojure/browser/net.cljs

@@ -104,7 +104,7 @@ Includes a common API over XhrIo, CrossPageChannel, and Websockets."
     ([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)))
+       (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)))
@@ -127,16 +127,17 @@ Includes a common API over XhrIo, CrossPageChannel, and Websockets."
   per the CrossPageChannel API."
   ([]
      (when-let [config (.getParameterValue
-                        (goog.Uri. (.href (.location js/window)))
+                        (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)))))
+      (reduce (fn [sum [k v]]
+                (if-let [field (get xpc-config-fields k)]
+                  (doto sum (aset field v))
+                  sum))
+              (js-obj)
+              config))))
 
 ;; WebSocket is not supported in the 3/23/11 release of Google
 ;; Closure, but will be included in the next release.

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

@@ -31,7 +31,7 @@
                     (catch js/Error e
                       {:status :exception :value (pr-str e)
                        :stacktrace (if (.hasOwnProperty e "stack")
-                                     (.stack e)
+                                     (.-stack e)
                                      "No stacktrace available.")}))]
     (pr-str result)))
 
@@ -105,5 +105,5 @@
     (net/connect repl-connection
                  (constantly nil)
                  (fn [iframe]
-                   (set! iframe.style.display
+                   (set! (.-display (.-style iframe))
                          "none")))))

data/ext/clojure-clojurescript-bef56a7/src/cljs/clojure/core/reducers.cljs

@@ -0,0 +1,298 @@
+;   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
+      "A library for reduction and parallel folding. Alpha and subject
+      to change.  Note that fold and its derivatives require
+      jsr166y.jar for fork/join support. See Clojure's pom.xml for the
+      dependency info."
+      :author "Rich Hickey"}
+  clojure.core.reducers
+  (:refer-clojure :exclude [reduce map mapcat filter remove take take-while drop flatten])
+  (:require [clojure.walk :as walk]
+            [cljs.core :as core]))
+
+(defn reduce
+  "Like core/reduce except:
+     When init is not provided, (f) is used.
+     Maps are reduced with reduce-kv"
+  ([f coll] (reduce f (f) coll))
+  ([f init coll]
+     (if (map? coll)
+       (-kv-reduce coll f init)
+       (-reduce coll f init))))
+
+#_
+(defprotocol CollFold
+  (coll-fold [coll n combinef reducef]))
+
+;;; TODO: update docstring for CLJS
+#_
+(defn fold
+  "Reduces a collection using a (potentially parallel) reduce-combine
+  strategy. The collection is partitioned into groups of approximately
+  n (default 512), each of which is reduced with reducef (with a seed
+  value obtained by calling (combinef) with no arguments). The results
+  of these reductions are then reduced with combinef (default
+  reducef). combinef must be associative, and, when called with no
+  arguments, (combinef) must produce its identity element. These
+  operations may be performed in parallel, but the results will
+  preserve order."
+  ([reducef coll] (fold reducef reducef coll))
+  ([combinef reducef coll] (fold 512 combinef reducef coll))
+  ([n combinef reducef coll]
+     (coll-fold coll n combinef reducef)))
+
+(def fold reduce)
+
+(defn reducer
+  "Given a reducible collection, and a transformation function xf,
+  returns a reducible collection, where any supplied reducing
+  fn will be transformed by xf. xf is a function of reducing fn to
+  reducing fn."
+  ([coll xf]
+     (reify
+       cljs.core/IReduce
+       (-reduce [this f1]
+         (-reduce this f1 (f1)))
+       (-reduce [_ f1 init]
+         (-reduce coll (xf f1) init)))))
+
+(defn folder
+  "Given a foldable collection, and a transformation function xf,
+  returns a foldable collection, where any supplied reducing
+  fn will be transformed by xf. xf is a function of reducing fn to
+  reducing fn."
+  ([coll xf]
+     (reify
+       cljs.core/IReduce
+       (-reduce [_ f1]
+         (-reduce coll (xf f1) (f1)))
+       (-reduce [_ f1 init]
+         (-reduce coll (xf f1) init))
+
+       #_
+       CollFold
+       #_
+       (coll-fold [_ n combinef reducef]
+         (coll-fold coll n combinef (xf reducef))))))
+
+(defcurried map
+  "Applies f to every value in the reduction of coll. Foldable."
+  {}
+  [f coll]
+  (folder coll
+   (fn [f1]
+     (rfn [f1 k]
+          ([ret k v]
+             (f1 ret (f k v)))))))
+
+(defcurried mapcat
+  "Applies f to every value in the reduction of coll, concatenating the result
+  colls of (f val). Foldable."
+  {}
+  [f coll]
+  (folder coll
+   (fn [f1]
+     (rfn [f1 k]
+          ([ret k v]
+             (reduce f1 ret (f k v)))))))
+
+(defcurried filter
+  "Retains values in the reduction of coll for which (pred val)
+  returns logical true. Foldable."
+  {}
+  [pred coll]
+  (folder coll
+   (fn [f1]
+     (rfn [f1 k]
+          ([ret k v]
+             (if (pred k v)
+               (f1 ret k v)
+               ret))))))
+
+(defcurried flatten
+  "Takes any nested combination of sequential things (lists, vectors,
+  etc.) and returns their contents as a single, flat foldable
+  collection."
+  {}
+  [coll]
+  (folder coll
+   (fn [f1]
+     (fn
+       ([] (f1))
+       ([ret v]
+          (if (sequential? v)
+            (-reduce (flatten v) f1 ret)
+            (f1 ret v)))))))
+
+(defcurried remove
+  "Removes values in the reduction of coll for which (pred val)
+  returns logical true. Foldable."
+  {}
+  [pred coll]
+  (filter (complement pred) coll))
+
+(defcurried take-while
+  "Ends the reduction of coll when (pred val) returns logical false."
+  {}
+  [pred coll]
+  (reducer coll
+   (fn [f1]
+     (rfn [f1 k]
+          ([ret k v]
+             (if (pred k v)
+               (f1 ret k v)
+               (reduced ret)))))))
+
+(defcurried take
+  "Ends the reduction of coll after consuming n values."
+  {}
+  [n coll]
+  (reducer coll
+   (fn [f1]
+     (let [cnt (atom n)]
+       (rfn [f1 k]
+         ([ret k v]
+            (swap! cnt dec)
+            (if (neg? @cnt)
+              (reduced ret)
+              (f1 ret k v))))))))
+
+(defcurried drop
+  "Elides the first n values from the reduction of coll."
+  {}
+  [n coll]
+  (reducer coll
+   (fn [f1]
+     (let [cnt (atom n)]
+       (rfn [f1 k]
+         ([ret k v]
+            (swap! cnt dec)
+            (if (neg? @cnt)
+              (f1 ret k v)
+              ret)))))))
+
+;;do not construct this directly, use cat
+(deftype Cat [cnt left right]
+  cljs.core/ICounted
+  (-count [_] cnt)
+
+  cljs.core/ISeqable
+  (-seq [_] (concat (seq left) (seq right)))
+  
+  cljs.core/IReduce
+  (-reduce [this f1] (-reduce this f1 (f1)))
+  (-reduce
+    [_  f1 init]
+    (-reduce
+     right f1
+     (-reduce left f1 init)))
+
+  #_
+  CollFold
+  #_
+  (coll-fold
+    [this n combinef reducef]
+    (-reduce this reducef)))
+
+(defn cat
+  "A high-performance combining fn that yields the catenation of the
+  reduced values. The result is reducible, foldable, seqable and
+  counted, providing the identity collections are reducible, seqable
+  and counted. The single argument version will build a combining fn
+  with the supplied identity constructor. Tests for identity
+  with (zero? (count x)). See also foldcat."
+  ([] (array))
+  ([ctor]
+     (fn
+       ([] (ctor))
+       ([left right] (cat left right))))
+  ([left right]
+     (cond
+       (zero? (count left)) right
+       (zero? (count right)) left
+       :else
+       (Cat. (+ (count left) (count right)) left right))))
+
+(defn append!
+  ".adds x to acc and returns acc"
+  [acc x]
+  (doto acc (.add x)))
+
+(defn foldcat
+  "Equivalent to (fold cat append! coll)"
+  [coll]
+  (fold cat append! coll))
+
+(defn monoid
+  "Builds a combining fn out of the supplied operator and identity
+  constructor. op must be associative and ctor called with no args
+  must return an identity value for it."
+  [op ctor]
+  (fn m
+    ([] (ctor))
+    ([a b] (op a b))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+(comment
+(require '[clojure.core.reduce :as r])
+(def v (take 1000000 (range)))
+(reduce + 0 (r/map inc [1 2 3 4]))
+(into [] (r/take 12 (range 100)))
+(into [] (r/drop 12 (range 100)))
+(reduce + 0 (r/filter even? [1 2 3 4]))
+(into [] (r/filter even? [1 2 3 4]))
+(reduce + (filter even? [1 2 3 4]))
+(dotimes [_ 10] (time (reduce + 0 (r/map inc v))))
+(dotimes [_ 10] (time (reduce + 0 (map inc v))))
+(dotimes [_ 100] (time (reduce + 0 v)))
+(dotimes [_ 100] (time (reduce + 0 v)))
+(dotimes [_ 20] (time (reduce + 0 (r/map inc (r/filter even? v)))))
+(dotimes [_ 20] (time (reduce + 0 (map inc (filter even? v)))))
+(reduce + 0 (r/take-while even? [2 4 3]))
+(into [] (r/filter even? (r/flatten (r/remove #{4} [[1 2 3] 4 [5 [6 7 8]] [9] 10]))))
+(into [] (r/flatten nil))
+)
+
+(comment
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; fold impls ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+(defn- foldvec
+  [v n combinef reducef]
+  (cond
+   (empty? v) (combinef)
+   (<= (count v) n) (reduce reducef (combinef) v)
+   :else
+   (let [split (quot (count v) 2)
+         v1 (subvec v 0 split)
+         v2 (subvec v split (count v))
+         fc (fn [child] #(foldvec child n combinef reducef))]
+     (fjinvoke
+      #(let [f1 (fc v1)
+             t2 (fjtask (fc v2))]
+         (fjfork t2)
+         (combinef (f1) (fjjoin t2)))))))
+
+(extend-protocol CollFold
+ Object
+ (coll-fold
+  [coll n combinef reducef]
+  ;;can't fold, single reduce
+  (reduce reducef (combinef) coll))
+ 
+ clojure.lang.IPersistentVector
+ (coll-fold
+  [v n combinef reducef]
+  (foldvec v n combinef reducef))
+
+ clojure.lang.PersistentHashMap
+ (coll-fold
+  [m n combinef reducef]
+  (.fold m n combinef reducef fjinvoke fjtask fjfork fjjoin)))
+
+)