Added all possible game values set

Added all possible game values set

--- src/skat/auction.clj
+++ src/skat/auction.clj
@@ -92,3 +92,26 @@
   (match [type]
     [:null] (null-game-value with-skat? ouvert?)
     [_]     (normal-game-value cards type with-skat? ouvert?)))
+
+;;; Possible game values
+
+(def min-normal-game-coefficients 2)
+(def max-normal-game-coefficients
+  ;            for playing | peaks | without skat | ouvert
+  { :grand  (+ 1             11      1              1),
+    :kreuz  (+ 1             7       1              1),
+    :grun   (+ 1             7       1              1),
+    :herz   (+ 1             7       1              1),
+    :schell (+ 1             7       1              1) })
+
+(def possible-game-values
+  (letfn [(vals-for [type]
+            (map #(* (game-type-coefficients type) %)
+                 (range min-normal-game-coefficients
+                        (inc (max-normal-game-coefficients type)))))]
+    (set (concat (vals null-game-values)
+                 (vals-for :grand)
+                 (vals-for :kreuz)
+                 (vals-for :grun)
+                 (vals-for :herz)
+                 (vals-for :schell)))))


not happy with this

not happy with this

--- src/wishlistd/cljs/main.cljs
+++ src/wishlistd/cljs/main.cljs
@@ -101,7 +101,8 @@
       (this-as me
         (when (value-changed?! me)
           (when (empty? (val me))
-            (remove (.parent me)))
+            (when-not (.hasClass "last" (.parent me))
+              (remove (.parent me))))
           (update-wishlist-rem))))))

 (defn wishlist-wish-url-changer []


Bug fixes

Bug fixes

--- src/wishlistd/cljs/main.cljs
+++ src/wishlistd/cljs/main.cljs
@@ -137,8 +137,8 @@
   (delegate $content ".url" :change
     (fn [e]
       (this-as me
-        (when-not (empty? (val ($ me)))
-          (update-wishlist-rem))))))
+        (when-not (empty? (.attr (.parent ($ me)) "id"))
+          (update-wish-rem (.parent ($ me))))))))

 (defn wishlist-delete-clicker []
   (delegate $content ".delete" :click


Fixed broadcast-game-info bug.

Fixed broadcast-game-info bug.

--- src/wombats/sockets/game.clj
+++ src/wombats/sockets/game.clj
@@ -135,8 +135,8 @@
   game-state)

 (defn broadcast-game-info
-  [{:keys [:game/game-id] :as game-state}]
-  (broadcast-to-viewers game-id
+  [{:keys [:game/id] :as game-state}]
+  (broadcast-to-viewers id
                         (m/game-info-message game-state))
   game-state)


Renamed old functions

Renamed old functions

--- src/tango/export.clj
+++ src/tango/export.clj
@@ -14,7 +14,7 @@
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; AdjPanelList/AdjList
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-(defn- make-adjudicator-node [adjudicator-info]
+(defn- old-make-adjudicator-node [adjudicator-info]
   (let [name (:adjudicator/name adjudicator-info)
         id (:adjudicator/id adjudicator-info)
         country (:adjudicator/country adjudicator-info)]
@@ -23,51 +23,51 @@
                                :Country country})
     ))

-(defn- make-adj-list-node [query-result]
+(defn- old-make-adj-list-node [query-result]
   (let [adjudicator-infos (map first query-result)]
     (xml/element
       :AdjList
       {:Qty (count adjudicator-infos)}
-      (map make-adjudicator-node (sort-by :adjudicator/id adjudicator-infos)))
+      (map old-make-adjudicator-node (sort-by :adjudicator/id adjudicator-infos)))
     ))

-(defn- export-adj-list [db]
+(defn- old-export-adj-list [db]
   (let [query-result (d/q '[:find (pull ?id [*])
                             :where
                             [?id :adjudicator/id]] db)]
-    (make-adj-list-node query-result)))
+    (old-make-adj-list-node query-result)))

 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; AdjPanelList/PanelList
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-(defn- make-panel-adj-node [query-result seq-number]
+(defn- old-make-panel-adj-node [query-result seq-number]
   (xml/element
     :PanelAdj
     {:Seq seq-number
      :AdjNumber (:adjudicator/id query-result)}))

-(defn- make-panel-node [panel seq-number]
+(defn- old-make-panel-node [panel seq-number]
   (let [adjudicator-infos (:adjudicator-panel/adjudicators panel)]
     (xml/element
       :Panel
       {:Seq seq-number
        :Qty (count adjudicator-infos)}
       (reduce
-        (fn [state adj-info] (conj state (make-panel-adj-node adj-info (count state))))
+        (fn [state adj-info] (conj state (old-make-panel-adj-node adj-info (count state))))
         []
         adjudicator-infos))))

-(defn- make-panel-list-node [adjudicator-panels]
+(defn- old-make-panel-list-node [adjudicator-panels]
   (xml/element
     :PanelList
     {:Qty (count adjudicator-panels)}
     (reduce (fn [elements panel]
-              (conj elements (make-panel-node panel (count elements))))
+              (conj elements (old-make-panel-node panel (count elements))))
             []
             adjudicator-panels)
   ))

-(defn- export-panel-list [db]
+(defn- old-export-panel-list [db]
   (let [qr (d/q '[:find (pull ?id [{:adjudicator-panel/adjudicators
                                                             [:adjudicator/id]}])
                                           :where
@@ -76,16 +76,16 @@
         n (- 30 (count adjudicator-panels))
         padded-panels (repeat n {:adjudicator-panel/adjudicators []})
         all-panels (into adjudicator-panels padded-panels)]
-    (make-panel-list-node all-panels)))
+    (old-make-panel-list-node all-panels)))

 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; AdjPanelList
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-(defn- export-adj-panel-list [db]
+(defn- old-export-adj-panel-list [db]
   (xml/element
     :AdjPanelList
     {}
-    (export-adj-list db)))
+    (old-export-adj-list db)))

 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; Utils
@@ -95,19 +95,19 @@
     (d/transact! conn [(uidb/sanitize data)])
     (d/db conn)))

-(defn- export-dance-perfect [db]
+(defn- old-export-dance-perfect [db]
   (xml/element
       :DancePerfect
       {:Version "4.1"}
-      [(export-adj-panel-list db)
-       (export-panel-list db)]
+      [(old-export-adj-panel-list db)
+       (old-export-panel-list db)]
       ))

-(defn export [data]
+(defn old-export [data]
   (let [db (get-db data)]
-    (export-dance-perfect db) ;; TODO: def queries in file and pass in query result
+    (old-export-dance-perfect db) ;; TODO: def queries in file and pass in query result
     ))

 (xml/indent-str
-  (export u/expected-small-example))
+  (old-export u/expected-small-example))


Inlined let-spy & let-spy-impl

Inlined let-spy & let-spy-impl

--- src/tupelo/impl.cljc
+++ src/tupelo/impl.cljc
@@ -449,23 +449,19 @@
        (spy-indent-dec)
        result#)))

-(defn- let-spy-impl
-  [exprs]
-  (let [decls (xfirst exprs)
-        _     (when (not (even? (count decls)))
-                (throw (IllegalArgumentException. (str "spy-let-proc: uneven number of decls:" decls))))
-        forms (xrest exprs)
-        fmt-pair (fn [[dest src]]
-                   [ dest src
-                     '_ (list 'spyx dest)] ) ; #todo gensym instead of underscore?
-        pairs (vec (partition 2 decls))
-        r1    (vec (mapcat fmt-pair pairs ))
-        final-code  `(let ~r1 ~@forms ) ]
-    final-code ))
-
 (defmacro let-spy
   [& exprs]
-  (let-spy-impl exprs))
+  (let [decls      (xfirst exprs)
+        _          (when (not (even? (count decls)))
+                     (throw (IllegalArgumentException. (str "spy-let-proc: uneven number of decls:" decls))))
+        forms      (xrest exprs)
+        fmt-pair   (fn [[dest src]]
+                     [dest src
+                      '_ (list 'spyx dest)]) ; #todo gensym instead of underscore?
+        pairs      (vec (partition 2 decls))
+        r1         (vec (mapcat fmt-pair pairs))
+        final-code `(let ~r1 ~@forms)]
+    final-code))

 ;-----------------------------------------------------------------------------
 (defn- let-spy-pretty-impl


worked on getting edit command working

worked on getting edit command working

--- src/mapfs/core.clj
+++ src/mapfs/core.clj
@@ -4,12 +4,15 @@
             ;[clojure.java.shell :refer [sh]]
             )
   (:import [jline TerminalFactory TerminalFactory$Flavor]
-           [jline.console ConsoleReader])
+           [jline.console ConsoleReader]
+           [java.lang ProcessBuilder$Redirect])
   (:gen-class :main true))

 (defonce ^:private FS_ROOT (atom nil))
 (defonce ^:private CURRENT_DIR (atom []))
 (defonce ^:private FS_FILENAME (atom nil))
+(defonce ^:private CONSOLE (atom nil))
+(defonce ^:private TERMINAL (atom nil))

 (defn write-fs!
   "Write current filesystem to filename as EDN."
@@ -166,13 +169,6 @@
   [src dest]
   (rename src dest))

-;(defn edit
-;  [value]
-;  (let [f (java.io.File/createTempFile "mapfs" "edn")]
-;    (spit f (pr-str value))
-;    (println f)
-;    (sh "vim" (.getAbsolutePath f)) ;; Doesn't work :(
-;    ))

 ;; SHELL COMMANDS

@@ -203,10 +199,30 @@

 (defn- init-terminal []
   (let [term (TerminalFactory/create)
-        console (ConsoleReader. System/in System/out)]
+        console (ConsoleReader. System/in System/out term)]
     (.init term)
     (.addCompleter console completion-handler)
+    (reset! TERMINAL term)
+    (reset! CONSOLE console)
     [term console]))
+
+(defn edit
+  [value]
+  (let [f (java.io.File/createTempFile "mapfs" "edn")]
+    (spit f (pr-str value))
+    (println f)
+    (.shutdown @CONSOLE)
+    ;(.restore @TERMINAL)
+    (let [pb (ProcessBuilder. ["vim" (.getAbsolutePath f)])
+          _ (.redirectInput pb ProcessBuilder$Redirect/INHERIT)
+          _ (.redirectOutput pb ProcessBuilder$Redirect/INHERIT)
+          p (.start pb)]
+      (.waitFor p))
+    (reset! CONSOLE (ConsoleReader. System/in System/out @TERMINAL))
+    (.reset @TERMINAL)
+    ;(init-terminal)
+    (slurp f)
+    ))

 (defn -main [& args]
   (println "Map FS - 0.1.0")
@@ -219,7 +235,7 @@
     (in-ns 'mapfs.core)
     (loop []
       (println)
-      (let [v (.readLine console "mapfs> ")]
+      (let [v (.readLine @CONSOLE "mapfs> ")]
         (when-not (= "exit" v)
           (try
             (println (eval (read-string (str "(" v ")"))))


tweaks

tweaks

--- src/yada/consume.clj
+++ src/yada/consume.clj
@@ -8,7 +8,8 @@
    [manifold.deferred :as d]
    [manifold.stream :as s]))

-(defn save-to-file [ctx body-stream f]
+;; Works ok
+#_(defn save-to-file [ctx body-stream f]
   (let [fos (new java.io.FileOutputStream f false)
         fc (.getChannel fos)]
     (d/chain
@@ -17,7 +18,7 @@

         (infof "count is %s" (:count ctx))
         (let [niobuf (b/to-byte-buffer buf)]
-          (infof "Writing single buffer" (.capacity niobuf))
+          (infof "Writing single buffer %s" (.capacity niobuf))
           (.write fc niobuf))

         (update ctx :count (fnil inc 0)))
@@ -27,3 +28,25 @@
        (.close fc)
        (.close fos)
        (assoc-in ctx [:file] f)))))
+
+
+(defn save-to-file [ctx body-stream f]
+  (let [fos (new java.io.FileOutputStream f false)
+        fc (.getChannel fos)]
+    (d/chain
+     (s/reduce
+      (fn [ctx buf]
+        #_(infof "count is %s" (:count ctx))
+        (.retain buf)
+        (let [niobuf (b/to-byte-buffer buf)]
+          #_(infof "Writing single buffer %s, refCnt is %s" (.capacity niobuf) (.refCnt buf))
+          (.write fc niobuf))
+        (.release buf)
+
+        (update ctx :count (fnil inc 0)))
+      ctx
+      body-stream)
+     (fn [ctx]
+       (.close fc)
+       (.close fos)
+       (assoc-in ctx [:file] f)))))


GG/CS #40 - remove user_guid from objective

--- test/d_cent/api_test.clj
+++ test/d_cent/api_test.clj
@@ -65,20 +65,17 @@
                               {:status 200
                                :headers {"Content-Type" "application/json"}
                                :body (json/generate-string
-                                      {:_id (str OBJECTIVE_ID)
+                                      {:_id OBJECTIVE_ID
                                        :title "Objective title"
                                        :goals "Objective goals"
                                        :description "Objective description"
-                                       :end-date "2015-01-31T00:00:00.000Z"
-                                       :user-guid (str USER_ID)})}]
+                                       :end-date "2015-01-31T00:00:00.000Z"})}]
                (api/get-objective OBJECTIVE_ID))
              => (contains {:_id OBJECTIVE_ID
                            :title "Objective title"
                            :goals "Objective goals"
                            :description "Objective description"
-                           :end-date (utils/time-string->date-time "2015-01-31T00:00:00.000Z")
-                           :user-guid USER_ID
-                           }))
+                           :end-date (utils/time-string->date-time "2015-01-31T00:00:00.000Z")}))
        (fact "returns api-failure when no objective found"
              (with-fake-http [(str host-url "/api/v1/objectives/" OBJECTIVE_ID)
                               {:status 404}]


Update the clojure fizzbuzz tests.

Update the clojure fizzbuzz tests.

--- fizzbuzz/clojure/fizzbuzz/test/fizzbuzz/core_test.clj
+++ fizzbuzz/clojure/fizzbuzz/test/fizzbuzz/core_test.clj
@@ -2,6 +2,21 @@
   (:require [clojure.test :refer :all]
             [fizzbuzz.core :refer :all]))

-(deftest a-test
-  (testing "FIXME, I fail."
-    (is (= 0 1))))
+(deftest fizzbuzz-val-test
+  (testing "Returns fizz for multiple of 3"
+    (is (= "fizz" (fizzbuzz-val 9))))
+  (testing "Returns buzz for multiple of 5"
+    (is (= "buzz" (fizzbuzz-val 10))))
+  (testing "Returns fizzbuzz for multiple of 15"
+    (is (= "fizzbuzz" (fizzbuzz-val 15))))
+  (testing "Returns stringified number for other values")
+    (is (= "13" (fizzbuzz-val 13))))
+
+(deftest generic-fizzbuzz-test
+  (testing "Returns vector of fizzbuzz results"
+    (is (= ["1" "2" "fizz" "4" "buzz" "fizz" "7" "8" "fizz"]
+           (generic-fizzbuzz 9)))))
+
+(deftest fizzbuzz-test
+  (testing "Returns vector of 100 fizzbuzz results"
+    (is (= 100 (count (fizzbuzz))))))


improve fabric logo

improve fabric logo


Split tests for setting and resetting DEC modes

--- test/asciinema_player/vt_test.cljs
+++ test/asciinema_player/vt_test.cljs
@@ -1410,119 +1410,129 @@
       (let [{:keys [tabs]} (feed-csi vt "3g")]
         (is (= tabs #{})))))

-  (testing "CSI h (SM)"
+  (testing "CSI 4h (SM)"
+    (let [vt (make-vt 80 24)
+          {:keys [insert-mode]} (feed-csi vt "4h")]
+      (is (= insert-mode true))))
+
+  (testing "CSI ?6h (DECSM)" ; set origin mode
+    (let [vt (-> (make-vt 80 24)
+                 (feed-csi "3;5r") ; set scroll region
+                 (move-cursor 1 1)
+                 (feed-csi "?6h"))
+          {:keys [origin-mode] {:keys [x y]} :cursor} vt]
+      (is (= origin-mode true))
+      (is (= x 0))
+      (is (= y 2))))
+
+  (testing "CSI ?7h (DECSM)" ; set auto-wrap mode
+    (let [vt (-> (make-vt 80 24)
+                 (feed-csi "?7h"))
+          {:keys [auto-wrap-mode]} vt]
+      (is (= auto-wrap-mode true))))
+
+  (testing "CSI ?25h (DECSM)" ; show cursor
+    (let [vt (-> (make-vt 80 24)
+                 hide-cursor
+                 (feed-csi "?25h")) ; show cursor
+          {{:keys [visible]} :cursor} vt]
+      (is (= visible true))))
+
+  (testing "CSI ?1047h (DECSM)"
     (let [vt (make-vt 4 3)]
-      (let [{:keys [insert-mode]} (feed-csi vt "4h")]
-        (is (= insert-mode true)))))
-
-  (testing "CSI ?h (DECSM)"
-    (let [vt (make-vt 20 10)]
-      (testing "showing cursor"
+      (testing "when in primary buffer"
         (let [vt (-> vt
-                     hide-cursor
-                     (feed-csi "?25h")) ; show cursor
-              {{:keys [visible]} :cursor} vt]
-          (is (= visible true))))
-      (testing "setting origin mode"
+                     (feed-str "ABC\nDE")
+                     (set-bg 2)
+                     (feed-csi "?1047h"))
+              {:keys [lines] {:keys [x y]} :cursor} vt]
+          (is (= x 2))
+          (is (= y 1))
+          (is (= lines [[[0x20 {:bg 2}] [0x20 {:bg 2}] [0x20 {:bg 2}] [0x20 {:bg 2}]]
+                        [[0x20 {:bg 2}] [0x20 {:bg 2}] [0x20 {:bg 2}] [0x20 {:bg 2}]]
+                        [[0x20 {:bg 2}] [0x20 {:bg 2}] [0x20 {:bg 2}] [0x20 {:bg 2}]]]))))
+      (testing "when in alternate buffer"
         (let [vt (-> vt
-                     (feed-csi "3;5r") ; set scroll region
-                     (move-cursor 1 1)
-                     (feed-csi "?6h")) ; set origin mode
-              {:keys [origin-mode] {:keys [x y]} :cursor} vt]
-          (is (= origin-mode true))
-          (is (= x 0))
-          (is (= y 2))))
-      (testing "setting auto-wrap mode"
-        (let [vt (feed-csi vt "?7h")
-              {:keys [auto-wrap-mode]} vt]
-          (is (= auto-wrap-mode true))))
-      (testing "setting multiple modes"
-        (let [vt (feed-csi vt "?6;7;25h")
-              {:keys [origin-mode auto-wrap-mode] {cursor-visible :visible} :cursor} vt]
-          (is (true? origin-mode))
-          (is (true? auto-wrap-mode))
-          (is (true? cursor-visible)))))
+                     (feed-csi "?1047h")
+                     (feed-str "ABC\nDE")
+                     (feed-csi "?1047h"))
+              {:keys [lines] {:keys [x y]} :cursor} vt]
+          (is (= x 2))
+          (is (= y 1))
+          (is (= lines [[[0x41 {}] [0x42 {}] [0x43 {}] [0x20 {}]]
+                        [[0x44 {}] [0x45 {}] [0x20 {}] [0x20 {}]]
+                        [[0x20 {}] [0x20 {}] [0x20 {}] [0x20 {}]]]))))))
+
+  (testing "CSI ?h (DECSM)" ; set multiple modes
+    (let [vt (-> (make-vt 80 24)
+                 (feed-csi "?6;7;25h"))
+          {:keys [origin-mode auto-wrap-mode] {cursor-visible :visible} :cursor} vt]
+      (is (true? origin-mode))
+      (is (true? auto-wrap-mode))
+      (is (true? cursor-visible))))
+
+  (testing "CSI 4l (RM)"
+    (let [vt (make-vt 80 24)
+          {:keys [insert-mode]} (feed-csi vt "4l")]
+      (is (= insert-mode false))))
+
+  (testing "CSI ?6l (DECRM)" ; reset origin mode
+    (let [vt (-> (make-vt 20 10)
+                 (feed-csi "3;5r") ; set scroll region
+                 (feed-csi "?6h") ; set origin mode
+                 (move-cursor 1 1)
+                 (feed-csi "?6l"))
+          {:keys [origin-mode] {:keys [x y]} :cursor} vt]
+      (is (= origin-mode false))
+      (is (= x 0))
+      (is (= y 0))))
+
+  (testing "CSI ?7l (DECRM)"
+    (let [vt (-> (make-vt 80 24)
+                 (feed-csi "?7l"))
+          {:keys [auto-wrap-mode]} vt]
+      (is (= auto-wrap-mode false))))
+
+  (testing "CSI ?25l (DECRM)" ; hide cursor
+    (let [vt (-> (make-vt 80 24)
+                 (feed-csi "?25l"))
+          {{:keys [visible]} :cursor} vt]
+      (is (= visible false))))
+
+  (testing "CSI ?1047l (DECRM)" ; switch to primary buffer
     (let [vt (make-vt 4 3)]
-      (testing "setting alternate screen mode"
-        (testing "when in primary buffer"
-          (let [vt (-> vt
-                       (feed-str "ABC\nDE")
-                       (set-bg 2)
-                       (feed-csi "?1047h"))
-                {:keys [lines] {:keys [x y]} :cursor} vt]
-            (is (= x 2))
-            (is (= y 1))
-            (is (= lines [[[0x20 {:bg 2}] [0x20 {:bg 2}] [0x20 {:bg 2}] [0x20 {:bg 2}]]
-                          [[0x20 {:bg 2}] [0x20 {:bg 2}] [0x20 {:bg 2}] [0x20 {:bg 2}]]
-                          [[0x20 {:bg 2}] [0x20 {:bg 2}] [0x20 {:bg 2}] [0x20 {:bg 2}]]]))))
-        (testing "when in alternate buffer"
-          (let [vt (-> vt
-                       (feed-csi "?1047h")
-                       (feed-str "ABC\nDE")
-                       (feed-csi "?1047h"))
-                {:keys [lines] {:keys [x y]} :cursor} vt]
-            (is (= x 2))
-            (is (= y 1))
-            (is (= lines [[[0x41 {}] [0x42 {}] [0x43 {}] [0x20 {}]]
-                          [[0x44 {}] [0x45 {}] [0x20 {}] [0x20 {}]]
-                          [[0x20 {}] [0x20 {}] [0x20 {}] [0x20 {}]]])))))))
-
-  (testing "CSI l (RM)"
-    (let [vt (make-vt 4 3)]
-      (let [{:keys [insert-mode]} (feed-csi vt "4l")]
-        (is (= insert-mode false)))))
-
-  (testing "CSI ?l (DECRM)"
-    (let [vt (make-vt 4 3)]
-      (testing "hiding cursor"
-        (let [vt (feed-csi vt "?25l"); hide cursor
-              {{:keys [visible]} :cursor} vt]
-          (is (= visible false))))
-      (testing "resetting origin mode"
+      (testing "when in primary buffer"
         (let [vt (-> vt
-                     (feed-csi "3;5r") ; set scroll region
-                     (feed-csi "?6h") ; set origin mode
-                     (move-cursor 1 1)
-                     (feed-csi "?6l")) ; reset origin mode
-              {:keys [origin-mode] {:keys [x y]} :cursor} vt]
-          (is (= origin-mode false))
-          (is (= x 0))
-          (is (= y 0))))
-      (testing "resetting auto-wrap mode"
-        (let [vt (feed-csi vt "?7l")
-              {:keys [auto-wrap-mode]} vt]
-          (is (= auto-wrap-mode false))))
+                     (feed-str "ABC\nDE")
+                     (feed-csi "?1047l")) ; set primary buffer
+              {:keys [lines] {:keys [x y]} :cursor} vt]
+          (is (= x 2))
+          (is (= y 1))
+          (is (= lines [[[0x41 {}] [0x42 {}] [0x43 {}] [0x20 {}]]
+                        [[0x44 {}] [0x45 {}] [0x20 {}] [0x20 {}]]
+                        [[0x20 {}] [0x20 {}] [0x20 {}] [0x20 {}]]]))))
+      (testing "when in alternate buffer"
+        (let [vt (-> vt
+                     (feed-str "ABC\nDE")
+                     (set-bg 2)
+                     (feed-csi "?1047h") ; set alternate buffer
+                     (feed-str "\nX")
+                     (feed-csi "?1047l")) ; set primary buffer
+              {:keys [lines] {:keys [x y]} :cursor} vt]
+          (is (= x 1))
+          (is (= y 2))
+          (is (= lines [[[0x41 {}] [0x42 {}] [0x43 {}] [0x20 {}]]
+                        [[0x44 {}] [0x45 {}] [0x20 {}] [0x20 {}]]
+                        [[0x20 {}] [0x20 {}] [0x20 {}] [0x20 {}]]]))))))
+
+  (testing "CSI ?l (DECRM)" ; reset multiple modes
+    (let [vt (make-vt 80 24)]
       (testing "resetting multiple modes"
         (let [vt (feed-csi vt "?6;7;25l")
               {:keys [origin-mode auto-wrap-mode] {cursor-visible :visible} :cursor} vt]
           (is (false? origin-mode))
           (is (false? auto-wrap-mode))
-          (is (false? cursor-visible)))))
-    (let [vt (make-vt 4 3)]
-      (testing "resetting alternate screen mode"
-        (testing "when in primary buffer"
-          (let [vt (-> vt
-                       (feed-str "ABC\nDE")
-                       (feed-csi "?1047l")) ; set primary buffer
-                {:keys [lines] {:keys [x y]} :cursor} vt]
-            (is (= x 2))
-            (is (= y 1))
-            (is (= lines [[[0x41 {}] [0x42 {}] [0x43 {}] [0x20 {}]]
-                          [[0x44 {}] [0x45 {}] [0x20 {}] [0x20 {}]]
-                          [[0x20 {}] [0x20 {}] [0x20 {}] [0x20 {}]]]))))
-        (testing "when in alternate buffer"
-          (let [vt (-> vt
-                       (feed-str "ABC\nDE")
-                       (set-bg 2)
-                       (feed-csi "?1047h") ; set alternate buffer
-                       (feed-str "\nX")
-                       (feed-csi "?1047l")) ; set primary buffer
-                {:keys [lines] {:keys [x y]} :cursor} vt]
-            (is (= x 1))
-            (is (= y 2))
-            (is (= lines [[[0x41 {}] [0x42 {}] [0x43 {}] [0x20 {}]]
-                          [[0x44 {}] [0x45 {}] [0x20 {}] [0x20 {}]]
-                          [[0x20 {}] [0x20 {}] [0x20 {}] [0x20 {}]]])))))))
+          (is (false? cursor-visible))))))

   (testing "CSI m (SGR)"
     (let [vt (make-vt 20 1)


remove obsolete file

remove obsolete file

git-svn-id: 03a8048b5ee8463be5048a3801110fb50f378627@13386 d0ab736e-dc22-4aeb-8dc9-08def0aa14fd

--- plugins/SlideExplorer2/src/slide_explorer/color_wheel.clj
+++ plugins/SlideExplorer2/src/slide_explorer/color_wheel.clj
@@ -1,73 +0,0 @@
-(ns slide-explorer.color-wheel
-  (:import (java.awt Color)
-           (java.awt.image BufferedImage))
-  (:require [slide-explorer.canvas :as canvas]
-            [slide-explorer.image :as image]
-            [clojure.java.io :as io]))
-
-(def PI_2 (* 2 Math/PI))
-
-(defn coords-to-hsb [x y]
-  (let [radius (Math/sqrt
-                 (+ (Math/pow x 2)
-                    (Math/pow y 2)))]
-    (cond (= 0 radius) {:hue 0 :saturation 0 :brightness 1.0}
-          (<= radius 1) {:hue (+ 0.5 (/ (Math/atan2 x y) PI_2))
-                         :saturation radius
-                         :brightness 1.0})))
-
-(defn hsb-to-color
-  "Convert an hsb map to a java awt Color object."
-  [{:keys [hue saturation brightness]}]
-  (when (and hue saturation brightness)
-    (Color/getHSBColor hue saturation brightness)))
-
-
-(defn wheel-description
-  "Canvas-style description of wheel."
-  [radius]
-  (let [ranges (range (- radius) (inc radius))]
-    (filter identity
-            (for [x ranges
-                  y ranges]
-              (let [color (hsb-to-color
-                            (coords-to-hsb
-                              (- (/ x radius))
-                              (- (/ y radius))))]
-                (when color
-                  [:line {:x x :y y :w 0 :h 0
-                           :color color}]))))))
-
-(defn wheel-image
-  "Create a wheel image (slow!)."
-  [radius]
-  (let [side (* 2 radius)
-        image (BufferedImage. side side BufferedImage/TYPE_INT_ARGB)
-        graphics (.createGraphics image)]
-    (canvas/draw
-      graphics
-      [:graphics {}
-       (concat [:compound {:x radius :y radius :w side :h side}]
-               (wheel-description radius))])
-    image))
-
-(defn generate-wheel-image
-  "Generate the wheel image and write it to a file."
-  [radius file]
-  (image/write-image file (wheel-image radius)))
-
-(comment
-  (generate-wheel-image 128 "hue-saturation-wheel.png")
-  )
-
-
-;; tests
-
-(defn hue-range []
-  (for [hue (range 0 1 0.001)]
-    (hsb-to-color {:hue hue :saturation 1.0 :brightness 1.0})))
-
-(def canvas-atom (atom nil))
-
-(defn wheel-test []
-  (canvas/canvas-frame canvas-atom))


Add bucket-props tests

Add bucket-props tests

--- test/icecap/store/riak_test.clj
+++ test/icecap/store/riak_test.clj
@@ -5,6 +5,32 @@
             [clojure.test.check.clojure-test :refer [defspec]]
             [clojurewerkz.welle.buckets :as wb]
             [clojurewerkz.welle.core :as wc]))
+
+(deftest bucket-props-test
+  (testing "default"
+    (is (= (bucket-props)
+            {:n-val 3
+             :r 1
+             :w 2
+             :dw 2
+
+             :notfound-ok false
+             :basic-quorum true
+
+             :allow-mult false
+             :last-write-wins true})))
+  (testing "custom n"
+    (is (= (bucket-props :n 2)
+            {:n-val 2
+             :r 1
+             :w 1
+             :dw 1
+
+             :notfound-ok false
+             :basic-quorum true
+
+             :allow-mult false
+             :last-write-wins true}))))

 (def riak-test-store)


Added five new tests into core-test module

--- test/emender_jenkins/core_test.clj
+++ test/emender_jenkins/core_test.clj
@@ -27,6 +27,36 @@
 ; Tests for various function definitions
 ;

+(deftest test-get-cors-headers-existence
+    "Check that the emender-jenkins.core/get-cors-headers definition exists."
+    (testing "if the emender-jenkins.core/get-cors-headers definition exists."
+        (is (callable? 'emender-jenkins.core/get-cors-headers))))
+
+
+(deftest test-origin-allowed?-existence
+    "Check that the emender-jenkins.core/origin-allowed? definition exists."
+    (testing "if the emender-jenkins.core/origin-allowed? definition exists."
+        (is (callable? 'emender-jenkins.core/origin-allowed?))))
+
+
+(deftest test-all-cors-existence
+    "Check that the emender-jenkins.core/all-cors definition exists."
+    (testing "if the emender-jenkins.core/all-cors definition exists."
+        (is (callable? 'emender-jenkins.core/all-cors))))
+
+
+(deftest test-start-server-on-regular-machine-existence
+    "Check that the emender-jenkins.core/start-server-on-regular-machine definition exists."
+    (testing "if the emender-jenkins.core/start-server-on-regular-machine definition exists."
+        (is (callable? 'emender-jenkins.core/start-server-on-regular-machine))))
+
+
+(deftest test-start-server-on-openshift-existence
+    "Check that the emender-jenkins.core/start-server-on-openshift definition exists."
+    (testing "if the emender-jenkins.core/start-server-on-openshift definition exists."
+        (is (callable? 'emender-jenkins.core/start-server-on-openshift))))
+
+
 (deftest test-start-server-existence
     "Check that the emender-jenkins.core/start-server definition exists."
     (testing "if the emender-jenkins.core/start-server definition exists."


Add timeout to take-segments!

Add timeout to take-segments!

--- test/onyx/plugin/input_test.clj
+++ test/onyx/plugin/input_test.clj
@@ -55,13 +55,11 @@
      (Thread/sleep 7000)
      (when (= (swap! batch-num inc) 2)
        (do
-         (println "throwing exception!")
          (throw (ex-info "Restartable" {:restartable? true}))))
      {})
    :lifecycle/handle-exception (constantly :restart)})

 (defn capitalize [segment]
-  (println "capitalizing: " (pr-str segment))
   (update-in segment [:name] clojure.string/upper-case))

 (defn pool [spec]
@@ -113,13 +111,7 @@
     (with-test-env [test-env [4 env-config peer-config]]
       (ensure-database! username password subname db-name)
       (onyx.test-helper/validate-enough-peers! test-env job)
-
-      (println "submitting job, waiting completion...")
-
       (->> (:job-id (onyx.api/submit-job peer-config job))
            (onyx.api/await-job-completion peer-config))
-
-      (println "job completed!")
-
-      (is (= (sort (map :name (butlast (take-segments! persist))))
+      (is (= (sort (map :name (take-segments! persist 10000)))
              (sort (mapv str (range 50))))))))


Fixing util-test.

Fixing util-test.

--- test/poky/kv/jdbc/util_test.clj
+++ test/poky/kv/jdbc/util_test.clj
@@ -18,6 +18,7 @@
                                       ; would require some refactoring of
                                       ; kv.jdbc to support in nested within
                                       ; sql/connection.
+                                      (create-bucket @@S bucket)
                                       (purge-bucket @@S bucket)
                                       ?form
                                       (close-connection @@S)))]


fix failed test case

fix failed test case

--- test/graphql_clj/executor_test.clj
+++ test/graphql_clj/executor_test.clj
@@ -112,7 +112,7 @@
           user-name "Mutation Test User"
           mutation (format "mutation {createUser(name: $name) {id name}}" user-name)
           context nil
-          variables {"name" user-name}
+          variables {:name user-name}
           result (execute context schema customized-resolver-fn mutation variables)]
       (is (= user-name (get-in result
                                [:data "createUser" "name"]))))))


Add more docs

Add more docs

--- exercise3/src/de/haw/vs/station.clj
+++ exercise3/src/de/haw/vs/station.clj
@@ -63,7 +63,7 @@
              (swap! state-atom assoc :slot))
     (if (message-was-send? state-atom in-chan connector)
       (read-messages connector (* after-slots duration-per-slot) after-slots) ; collision free sending
-      (some->> (read-messages connector (* after-slots duration-per-slot) after-slots)
+      (some->> (read-messages connector (* after-slots duration-per-slot) after-slots) ;if collision during sending, take a new slot
                (find-free-slots @free-slots)
                (rand-nth)
                (log-slot)


Improve error handling when there are only unplayable queues

--- test/onyx/log/generators.clj
+++ test/onyx/log/generators.clj
@@ -100,9 +100,9 @@
                                           (map key)
                                           set)
                     selectable-queues (into selectable-peers peerless-queues)]
-                (when (empty? selectable-queues)
-                  (println "No playable log messages. State: " state))
-                (gen/elements selectable-queues)))))
+                (if (empty? selectable-queues)
+                  (throw (Exception. (str "No playable log messages. State: " state)))
+                  (gen/elements selectable-queues))))))

 (defn apply-entry-gen
   "Apply an entry from one of the peers log queues


Fix formatting

Fix formatting

--- test/pronouns/pages_test.clj
+++ test/pronouns/pages_test.clj
@@ -3,7 +3,7 @@
             [clojure.test :refer [deftest testing is are]]))

 (deftest prose-comma-list
-  (testing "prose-comma-list turns a list of strings into a prose list"
+  (testing "`prose-comma-list` turns a list of strings into a prose list"
     (are [v s] (= (pages/prose-comma-list v) s)
       ["foo" "bar" "baz" "bobble"] "foo, bar, baz, and bobble"
       ["foo" "bar" "baz"]          "foo, bar, and baz"
@@ -17,7 +17,7 @@
          pronouns)
     ["she/her"]           '(["she" "her" "her" "hers" "herself"])
     ["she" "they"]        '(["she" "her" "her" "hers" "herself"]
-                           ["they" "them" "their" "theirs" "themselves"])
+                            ["they" "them" "their" "theirs" "themselves"])
     ["she/her" "foo/bar"] '(["she" "her" "her" "hers" "herself"])
     ["foo/bar"]           '()
     ["a/b/c/d/e"]         '(("a" "b" "c" "d" "e"))))


Fix three #?(:clj ...) line errors in tests.

--- test/zprint/zprint_test.cljc
+++ test/zprint/zprint_test.cljc
@@ -1304,7 +1304,8 @@

   ;!zprint {:format :skip}
   ; Something strange going on with source-fn and :clj!
-  #?(:clj (deftype Typetest [cnt _meta]
+  #?(:clj
+  (deftype Typetest [cnt _meta]
             clojure.lang.IHashEq
               (hasheq [this] (list this))
             clojure.lang.Counted
@@ -1536,7 +1537,8 @@

   ;!zprint {:format :skip}
   ; Something strange going on with source-fn and :clj!
-  #?(:clj (deftype Typetest1 [cnt _meta]
+  #?(:clj
+  (deftype Typetest1 [cnt _meta]
             clojure.lang.IHashEq
               (hasheq [this]
                 (list this)
@@ -1610,7 +1612,8 @@

   ;!zprint {:format :skip}
   ; Something strange going on with defn/def source-fn and :clj!
-  #?(:clj (defn zctest8x
+  #?(:clj
+  (defn zctest8x
             []
             (let [a (list 'with 'arguments)
                   foo nil


add missing compile option :load-test and docs to schema

--- sidecar/src/figwheel_sidecar/schemas/cljs_options.clj
+++ sidecar/src/figwheel_sidecar/schemas/cljs_options.clj
@@ -317,6 +317,14 @@

   :source-map-path \"public/js\"")

+(def-key ::source-map-asset-path            string?
+
+  "Provides fine grained control over the sourceMappingURL comment that
+is appended to generated JavaScript files when source mapping is enabled.
+further web server configuration.
+
+  :source-map-asset-path \"http://foo.com/public/js/out\"")
+
 (def-key ::source-map-timestamp       boolean?

   "Add cache busting timestamps to source map urls. This is helpful for
@@ -358,6 +366,16 @@
   :static-fns true")

 ;; (def-key ::warnings                   (ref-schema 'CompilerWarnings))
+
+(def-key ::load-tests              boolean?
+
+  "This flag will cause deftest from cljs.test to be ignored if false.
+
+Useful for production if deftest has been used in the production classpath.
+
+Default is true. Has the same effect as binding cljs.analyzer/*load-tests*.
+
+  :load-tests true")

 (def-key ::elide-asserts              boolean?

@@ -832,6 +850,7 @@
      ::cache-analysis
      ::recompile-dependents
      ::static-fns
+     ::load-tests
      ::elide-asserts
      ::pseudo-names
      ::print-input-delimiter


comment out the close callback until Stripe fixes things

--- frontend/stripe.cljs
+++ frontend/stripe.cljs
@@ -24,7 +24,10 @@
                     checkout-args
                     ;; XXX: check what happens on failure
                     {:token #(put! channel [:stripe-checkout-succeeded (utils/js->clj-kw %)])
-                     :closed #(put! channel [:stripe-checkout-closed])})]
+                     ;; XXX: remove this when Stripe gets back to us about `close` being fired when the
+                     ;;      form is submitted. Or come up with a workaround if they don't fix it.
+                     ;;:closed #(put! channel [:stripe-checkout-closed])
+                     })]
     ((aget checkout "open") (clj->js args))))

 (defn checkout-loaded?


Another direction, in progress.

Another direction, in progress.

--- src/angelic/search/incremental/implicit_fah_astar.clj
+++ src/angelic/search/incremental/implicit_fah_astar.clj
@@ -26,11 +26,215 @@

 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;;;;;;;;;;;;;;;;;;;;;;;;;;;; Subproblem Protocols ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-
-;;Clear how costs must go
-;;How should sets go -- eager or lazy ? ? ???
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; Function Sets ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defprotocol FunctionSet
+  (fs-name    [sk]           "Arbitrary name to identify fs")
+  (apply-opt  [sk input-set] "[output-set upper-reward-bound] or nil if empty")
+  (status     [sk input-set] ":live, :blocked, or :solved")
+  (child-seqs [sk input-set] "seq of seqs of FunctionSets. Only valid if above is :live.
+                              (= :live (status sk s)) ==>
+                                 (subset? (child-seqs sk s-subset) (child-seqs sk s)) (for names)"))
+
+;; Child-seqs must obey the containment property for subsets of input-set.
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; Planning Kernels ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defn make-primitive-fs [action]
+  (reify FunctionSet
+    (fs-name    [sk]           (env/action-name action))
+    (apply-opt  [sk input-set] (angelic/optimistic-set-and-reward action input-set))
+    (status     [sk input-set] :solved)
+    (child-seqs [sk input-set] (throw (UnsupportedOperationException.)))))
+
+(defn- simple-immediate-refinements-set [a input-set]
+  (for [[constraint ref] (angelic/immediate-refinements-set a input-set)]
+    (cons
+     (env-util/make-factored-primitive [:noop] constraint {} 0)
+     ref)))
+
+(defn make-hla-fs [action]
+  (reify FunctionSet
+         (fs-name [sk] (env/action-name action))
+         (compute-output-set-and-reward   [sk input-set]
+            (angelic/optimistic-set-and-reward action input-set))
+         (compute-status   [sk input-set]
+            (if (angelic/can-refine-from-set? action input-set) :live :blocked))
+         (compute-child-fs-seqs [sk input-set child-key]
+            (for [ref (simple-immediate-refinements-set action input-set)]
+              (for [a ref]
+                ((if (env/primitive? action) make-primitive-fs make-hla-fs) action))))))
+
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;; Subproblem Protocol ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;; For now, go with simple "complete eval" formulation.
+;; Will have "atomic" and "seq" subproblems -- separate impls..
+
+(def no-children :terminal)
+
+(defprotocol Subproblem
+  (input-set       [s])
+  (output-set      [s])
+;  (current-summary [s])
+  (child-keys      [s] "seq or no-children")
+  (get-child       [s child-key])
+  (refine-input-   [s refined-input-set] "must be a strict subset of input-set."))
+
+(defn refine-input [s maybe-refined-input-set]
+  (if (= (input-set s) maybe-refined-input-set)
+    s
+    (refine-input- s maybe-refined-input-set)))
+
+
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;; Simple FS Subproblem ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;; Very simple, no caching or reuse or anything.
+
+(declare make-simple-fs-seq-subproblem)
+
+(defn make-simple-atomic-subproblem [inp-set function-set]
+  (let [out-set (apply-opt function-set inp-set)
+        stat    (fs-status function-set)
+        fs-child-seqs (when (= stat :live) (child-seqs function-set inp-set))
+        fs-child-seqs-map (zipmap (map #(map fs-name %) fs-child-seqs) fs-child-seqs)]
+    (assert (= (count fs-child-seqs-map) (count fs-child-seqs)))
+    (reify
+     Subproblem
+     (input-set       [s] inp-set)
+     (output-set      [s] out-set)
+     (child-keys      [s] (if (= stat :live) (keys fs-child-seqs-map) no-children))
+     (get-child       [s child-key]
+       (->> (util/safe-get fs-child-seqs-map child-key)
+            (make-simple-factored-seq-subproblem inp-set)))
+     (refine-input    [s refined-input-set]
+       (make-simple-atomic-subproblem refined-input-set function-set)))))
+
+
+;; NOTE: If we require that input and output match always, we just get back AHA*.
+;; (but with UP, perhaps caching?).
+
+
+(declare make-simple-pair-subproblem)
+
+(defn make-aligned-simple-pair-subproblem [sp1 sp2]
+  (make-simple-pair-subproblem sp1 (refine-input sp2 (output-set sp1))))
+
+(defn simple-pair-child-keys [sp1 sp2]
+  (let [sp2-child-keys (child-keys sp2)]
+    (if (= sp2-child-keys no-children)
+      (let [sp1-child-keys (child-keys sp1)]
+        (if (= sp1-child-keys no-children)
+          no-children
+          (map #(vector ::1 %) sp1-child-keys)))
+      (map #(vector ::2 %) sp2-child-keys))))
+
+(defn simple-pair-child [sp1 sp2 child-key]
+  (let [[which sub-key] child-key]
+    (case which
+      ::1 (make-aligned-simple-pair-subproblem (get-child sp1 sub-key) sp2)
+      ::2 (make-simple-pair-subproblem sp1 (get-child sp2 sub-key)))))
+
+
+(defn make-simple-pair-subproblem [sp1 sp2]
+  (let [child-keys (simple-pair-child-keys sp1 sp2)]
+    (reify
+     Subproblem
+     (input-set       [s] (input-set sp1))
+     (output-set      [s] (output-set sp2))
+     (child-keys      [s] child-keys)
+     (get-child       [s child-key] (simple-pair-child sp1 sp2 child-key))
+     (refine-input    [s refined-input-set]
+       (make-aligned-simple-pair-subproblem (refine-input sp1 refined-input-set) sp2)))))
+
+(defn make-simple-fs-seq-subproblem [inp-set [first-fs & rest-fs]]
+  (let [first-sp (make-simple-atomic-subproblem inp-set first-fs)]
+    (if (empty? rest-fs)
+      first-sp
+      (->> (make-simple-fs-seq-subproblem (output-set first-sp) rest-fs)
+           (make-simple-pair-subproblem first-sp)))))
+
+
+
+
+
+
+(comment ; old version- has some caching.
+ (defn make-simple-atomic-subproblem [inp-set function-set]
+   (let [child-cache (HashMap.)
+         refinement-cache (HashMap.)
+         out-set (apply-opt function-set inp-set)
+         fs-child-seqs (child-seqs function-set inp-set)
+         fs-child-seqs-map (zipmap (map #(map fs-name %) fs-child-seqs) fs-child-seqs) ]
+     (assert (= (count fs-child-seqs-map) (count fs-child-seqs)))
+     (reify
+      Subproblem
+      (input-set       [s] inp-set)
+      (output-set      [s] out-set)
+      (child-keys      [s] (keys fs-child-seqs-map))
+      (get-child       [s child-key]
+                       (->> (util/safe-get fs-child-seqs-map child-key)
+                            (make-simple-factored-seq-subproblem inp-set)
+                            (util/cache-with child-cache child-key)))
+      (refine-input    [s refined-input-set]
+                       (make-simple-atomic-subproblem refined-input-set function-set))))))
+
+(declare make-generic-subproblem)
+
+(defrecord GenericSubproblem [; ??? summarizer
+                              kernel in-set out-set child-key-seq
+                              ^HashMap child-cache ^HashMap refinement-cache]
+  (input-set       [s] in-set)
+  (output-set      [s] out-set)
+  (current-summary [s] ...???)
+  (child-keys      [s] child-key-seq)
+  (get-child       [s child-key]
+    (util/cache-with child-cache child-key (compute-child-kernel kernel in-set child-key)))
+  (refine-input    [s refined-input-set]
+    (if (= in-set refined-input-set)
+      s
+      (util/cache-with refinement-cache refined-input-set
+                       (make-generic-subproblem kernel refined-input-set)))))
+
+(defn make-generic-subproblem [kernel input-set]
+  (GenericSubproblem.
+   kernel
+   input-set
+   (compute-output-set kernel input-set)
+   (compute-child-keys kernel input-set)
+   (HashMap.) (HashMap.)))
+
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;; TopDown FS Subproblem ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;; Add caching, exploitation of subsumption, but no graphiness
+
+
+
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; Simple Planning ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;; Problem we run into here: splitting into plans without factored costs
+;; = potentially very expensive queue mgmt.
+
+;; Planning is defined only on Summarizer + a refinement operation.
+
+
+(defprotocol )
+
+
+
+
 ;;Can forget about sets -- switch to breakout children instead.

 ;; Things:
@@ -58,21 +262,83 @@
 (def no-children :terminal)

 (defprotocol Subproblem
+  (input-set       [s])
+  (output-set      [s])
   (current-summary [s])
   (child-keys      [s] "seq or no-children")
   (get-child       [s child-key])
   (refine-input    [s refined-input-set]))

-(def input-set :input-set)
-(def output-set :output-set)
-(defn get-child-map [s] (into {} (for [k (child-keys s)] [k (get-child s k)])))
-
+;;(def input-set :input-set)
+;;(def output-set :output-set)
+;;(defn get-child-map [s] (into {} (for [k (child-keys s)] [k (get-child s k)])))
+
+
+
+
+
+;; TODO: getting child from super ...
+(declare make-generic-subproblem)
+
+(defrecord GenericSubproblem [; ??? summarizer
+                              kernel in-set out-set child-key-seq
+                              ^HashMap child-cache ^HashMap refinement-cache]
+  (input-set       [s] in-set)
+  (output-set      [s] out-set)
+  (current-summary [s] ...???)
+  (child-keys      [s] child-key-seq)
+  (get-child       [s child-key]
+    (util/cache-with child-cache child-key (compute-child-kernel kernel in-set child-key)))
+  (refine-input    [s refined-input-set]
+    (if (= in-set refined-input-set)
+      s
+      (util/cache-with refinement-cache refined-input-set
+                       (make-generic-subproblem kernel refined-input-set)))))
+
+(defn make-generic-subproblem [kernel input-set]
+  (GenericSubproblem.
+   kernel
+   input-set
+   (compute-output-set kernel input-set)
+   (compute-child-keys kernel input-set)
+   (HashMap.) (HashMap.)))
+
+
+
+
+(declare make-generic-wrapping-subproblem)
+
+(defrecord GenericWrappingSubproblem [super-sp root-sp key-trail ; summarizer???
+                                      kernel in-set out-set child-key-seq
+                                      ^HashMap child-cache ^HashMap refinement-cache]
+  Subproblem
+  (input-set       [s] in-set)
+  (output-set      [s] out-set)
+  (current-summary [s] ...???)
+  (child-keys      [s] child-key-seq)
+  (get-child       [s] ???)
+  (refine-input    [s refined-input-set]
+    (if (= in-set refined-input-set)
+      s
+      (util/cache-with refinement-cache refined-input-set
+                       ???))))
+
+(defn make-generic-subproblem [name super-sp root-sp key-trail summary???
+                               in-set .....])
+
+
+(defn make-refinement-kernel [actions]
+  (let [[f & r] (util/make-safe actions)
+        left-k (make-action-kernel f)]
+    (if (empty? r)
+      left-k
+      (make-seq-kernel left-k (make-refinement-kernel r)))))

 ;; TODO: simple generic SimpleSubproblem record ?

 ;; TODO: stop early on empty sets or bad rewards, etc.
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;; Planning Subproblems ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; Planning Kernels ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

 (declare make-primitive-subproblem)
@@ -83,97 +349,95 @@

 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; Primitive ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

-;; No need to worry about supers?
-(defrecord PrimitiveSubproblem [input-set action output-set summary]
-  Subproblem
-  (current-summary [s] summary)
-  (child-keys      [s] no-children)
-  (get-child       [s child-key] (throw (RuntimeException.)))
-  (refine-input    [s refined-input-set]
-    (if (= input-set refined-input-set)
-      s
-      (make-primitive-subproblem refined-input-set action))))
-
-(defn make-primitive-subproblem [input-set action]
-  (let [[output-set rew] (angelic/optimistic-set-and-reward action input-set)]
-    (PrimitiveSubproblem. input-set action output-set (summary/make-solved-simple-summary rew action ))))
-
+(defn make-primitive-kernel [action]
+  (reify SubproblemKernel
+         (compute-output-set-and-reward   [sk input-set]
+            (angelic/optimistic-set-and-reward action input-set))
+         (compute-child-keys   [sk input-set]
+            no-children)
+         (compute-child-kernel [sk input-set child-key]
+            (throw (UnsupportedOperationException.)))))

 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; HLA ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-
-(defrecord HlaSubproblem [super-hs input-set action output-set
-                          summarizer child-map ^HashMap refinement-map]
-  Subproblem
-  (current-summary [s] ...?)
-  (child-keys      [s] (keys child-map))
-  (get-child       [s child-key] (force (util/safe-get child-map child-key)))
-  (refine-input    [s refined-input-set]
-    (if (= refined-input-set input-set)
-      s
-      (util/cache-with refinement-map refined-input-set
-                       (make-hla-subproblem s refined-input-set action)))))
-
-(defn make-constraint-primitive [constraint]
-  (env-util/make-factored-primitive [:noop] constraint {} 0))

 (defn simple-immediate-refinements-set [a input-set]
   (for [[constraint ref] (angelic/immediate-refinements-set a input-set)]
-    (cons (make-constraint-primitive constraint) ref)))
-
-(defn make-refinement-subproblem [parent-hs input-set actions]
+    (cons
+     (env-util/make-factored-primitive [:noop] constraint {} 0)
+     ref)))
+
+(defn make-refinement-kernel [actions]
   (let [[f & r] (util/make-safe actions)
-        left-sp (make-atomic-subproblem nil input-set a)]
+        left-k (make-action-kernel f)]
     (if (empty? r)
-      left-sp
-      ???....
-      left-sp
-      (make-refinement-subproblem parent-hs (output-set left-sp) r))))
-
-
-(defn make-hla-subproblem [super-hs input-set action]
-  (let [[opt-set rew] (angelic/optimistic-set-and-reward action input-set)]
-    (HlaSubproblem.
-     super-hs input-set action opt-set ??????summarizer
-     (cond (not (angelic/can-refine-from-set? action input-set))
+      left-k
+      (make-seq-kernel left-k (make-refinement-kernel r)))))
+
+;; TODO: handle proper key matching ?
+(defn make-hla-kernel [action]
+  (reify SubproblemKernel
+         (compute-output-set-and-reward   [sk input-set]
+            (angelic/optimistic-set-and-reward action input-set))
+         (compute-child-keys   [sk input-set]
+            (simple-immediate-refinements-set action input-set))
+         (compute-child-kernel [sk input-set child-key]
+            (make-refinement-kernel child-key))))
+
+(defn make-action-kernel [action]
+  ((if (env/primitive? action) make-primitive-kernel make-hla-kernel) action))
+
+
+(comment
+  (defn make-hla-subproblem [super-hs input-set action]
+    (let [[opt-set rew] (angelic/optimistic-set-and-reward action input-set)]
+      (HlaSubproblem.
+       super-hs input-set action opt-set ??????summarizer
+       (cond (not (angelic/can-refine-from-set? action input-set))
              no-children
-           (and super-hs (not (blocked??? super-hs)))
-             ??? ;reuse
-           :else
+             (and super-hs (not (blocked??? super-hs)))
+             ???                        ;reuse
+             :else
              (into {}
                    (for [ref (simple-immediate-refinements-set action input-set)]
                      [(map env/action-name ref)
                       (delay (make-refinement-subproblem this??? input-set ref))
                       (ActionInstance. ai nil prev-aio full-ref (atom nil))])))
-     (HashMap.))))
-
-
-(defn make-atomic-subproblem [super-as input-set action]
-  (if (env/primitive? action)
-    (make-primitive-subproblem input-set action)
-    (make-hla-subproblem parent-as input-set action)))
+       (HashMap.)))))
+

 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; Sequence ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

-
-;; For now, pick the right first if possible -- fix later.
-;; TODO: unfactor ?
-;; TODO: how do we wrap partial SPs?
-(defrecord SeqSubproblem [super-sp root-hs key-seq
-                          input-set left-sp right-sp output-constraint
-                          child-map]
-  Subproblem
-  (current-summary [s] ...?)
-  (child-keys      [s] (keys child-map))
-  (get-child       [s child-key] (force (util/safe-get child-map child-key)))
-  (refine-input    [s refined-input-set]
-    (if (= refined-input-set input-set)
-      s
-      (util/cache-with refinement-map refined-input-set
-                       (make-hla-subproblem s refined-input-set action)))))
-
-
-(defn make-seq-subproblem [super-sp root-hs key-seq])
+(defn make-seq-kernel [left-k right-k]
+  (reify SubproblemKernel
+         (compute-output-set-and-reward   [sk input-set]
+            (angelic/optimistic-set-and-reward action input-set))
+         (compute-child-keys   [sk input-set]
+            (simple-immediate-refinements-set action input-set))
+         (compute-child-kernel [sk input-set child-key]
+            (make-refinement-kernel child-key))))
+
+
+(comment
+
+ ;; For now, pick the right first if possible -- fix later.
+ ;; TODO: unfactor ?
+ ;; TODO: how do we wrap partial SPs?
+ (defrecord SeqSubproblem [super-sp root-hs key-seq
+                           input-set left-sp right-sp output-constraint
+                           child-map]
+   Subproblem
+   (current-summary [s] ...?)
+   (child-keys      [s] (keys child-map))
+   (get-child       [s child-key] (force (util/safe-get child-map child-key)))
+   (refine-input    [s refined-input-set]
+                    (if (= refined-input-set input-set)
+                      s
+                      (util/cache-with refinement-map refined-input-set
+                                       (make-hla-subproblem s refined-input-set action)))))
+
+
+ (defn make-seq-subproblem [super-sp root-hs key-seq]))

 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; Wrapped Seq ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;


Fix quoting

Fix quoting

--- src/clojure/clojurewerkz/cassaforte/new_query_api.clj
+++ src/clojure/clojurewerkz/cassaforte/new_query_api.clj
@@ -57,7 +57,11 @@

 (defn desc
   [^String column-name]
-  (QueryBuilder/desc column-name))
+  (QueryBuilder/desc (name column-name)))
+
+(defn quote*
+  [s]
+  (QueryBuilder/quote (name s)))

 (def ^:private query-type-map
   {:in in
@@ -153,7 +157,7 @@
      (build-where m (.where query-builder)))])

 (defn order-by
-  [orderings]
+  [& orderings]
   [:order
    (fn order-by-query [^Select$Where query-builder]
      (.orderBy query-builder (into-array orderings)))])


lein-release plugin: bumped version from 0.4.13 to 0.4.14-SNAPSHOT for next development cycle

--- re_view/project.clj
+++ re_view/project.clj
@@ -1,4 +1,4 @@
-(defproject re-view "0.4.13"
+(defproject re-view "0.4.14-SNAPSHOT"
   :description "ClojureScript React Library"
   :url "https://www.github.com/braintripping/re-view/tree/master/re_view"
   :license {:name "Eclipse Public License"


Few corrections on project.clj

Few corrections on project.clj

--- project.clj
+++ project.clj
@@ -17,8 +17,6 @@
             [lein-midje "3.0.0"]]

   :profiles { :test {:resource-paths ["resources/test"]}
-              ; :default {:resource-paths ["resources/main"]}
-              ; :prod {:resource-paths ["resources/main"] }
               :dev
                     {:resource-paths ["resources/dev"]
                      :dependencies [[javax.servlet/servlet-api "2.5"]


Preparing for new release

Preparing for new release

--- project.clj
+++ project.clj
@@ -1,5 +1,5 @@
-(defproject effectivejava "0.1.1-SNAPSHOT"
-  :description "A tool for running queries on your Java codebase"
+(defproject effectivejava "0.1.2-SNAPSHOT"
+  :description "A Java linter and a tool for running queries on your Java codebase"
   :dependencies [[org.clojure/clojure "1.6.0"]
                  [com.google.code.javaparser/javaparser "1.0.12-SNAPSHOT"]
                  [org.clojure/tools.cli "0.3.1"]


Leiningen dev dependencies are not needed

--- project.clj
+++ project.clj
@@ -3,10 +3,6 @@

   :dependencies [[org.clojure/clojure   "1.3.0"]
                  [org.jboss.netty/netty "3.2.4.Final"]]
-
-  :dev-dependencies [[swank-clojure "1.3.4-SNAPSHOT" :exclusions [org.clojure/clojure]]
-                     [robert/hooke  "1.1.2"]
-                     [lein-clojars  "0.7.0"]]

   :source-path      "src/clj"
   :java-source-path "src/jvm"


update http-kit to stable version

update http-kit to stable version

--- project.clj
+++ project.clj
@@ -6,7 +6,7 @@
                  [javax.servlet/servlet-api "2.5"]
                  [commons-codec "1.10"]
                  [commons-validator "1.5.1"]
-                 [http-kit "2.2.0-alpha1"]
+                 [http-kit "2.2.0"]
                  [ring/ring-defaults "0.2.1"]
                  [fogus/ring-edn "0.3.0"]
                  [ring-cors "0.1.8"]


Bump version

Bump version

--- project.clj
+++ project.clj
@@ -1,4 +1,4 @@
-(defproject keechma/keechma "0.3.8"
+(defproject keechma/keechma "0.3.9"
   :description "Frontend micro framework for ClojureScript and Reagent"
   :url "http://github.com/keechma/keechma"
   :license {:name "MIT"}


Formatting

Formatting

--- project.clj
+++ project.clj
@@ -24,8 +24,7 @@
                  [cljs-ajax "0.3.9"]
                  [org.clojure/core.async "0.1.346.0-17112a-alpha"]]

-  :plugins [
-            [lein-cljsbuild "1.0.4"]
+  :plugins [[lein-cljsbuild "1.0.5"]
             [lein-environ "1.0.0"]
             [lein-ring "0.9.0"]
             [lein-asset-minifier "0.2.2"]]
@@ -41,15 +40,12 @@

   :cljsbuild {
     :builds {
-      :app {
         :source-paths ["src/cljs"]
         :compiler {
           :output-to  "resources/public/js/app.js"
           :output-dir "resources/public/js/out"
-          :externs    ["resources/public/js/jquery-ui.js"
-                       "resources/public/js/jquery-2.1.3.min.js"]
           :optimizations :whitespace
-          :pretty-print  true}}}}
+          :pretty-print  true}}}

   :profiles {
     :dev {
@@ -57,27 +53,27 @@
         :init-ns decktouch.handler
         :nrepl-middleware [cemerick.piggieback/wrap-cljs-repl]}

-        :dependencies [[ring-mock "0.1.5"]
-                       [ring/ring-devel "1.3.2"]
-                       [pjstadig/humane-test-output "0.6.0"]]
+      :dependencies [[ring-mock "0.1.5"]
+                     [ring/ring-devel "1.3.2"]
+                     [pjstadig/humane-test-output "0.6.0"]]

-        :plugins [[lein-figwheel "0.2.0-SNAPSHOT"]]
+      :plugins [[lein-figwheel "0.2.0-SNAPSHOT"]]

-        :injections [(require 'pjstadig.humane-test-output)
-                     (pjstadig.humane-test-output/activate!)]
+      :injections [(require 'pjstadig.humane-test-output)
+                   (pjstadig.humane-test-output/activate!)]

-        :figwheel {:http-server-root "public"
-                   :server-port 3449
-                   :css-dirs ["resources/public/css"]
-                   :ring-handler decktouch.handler/app}
+      :figwheel {:http-server-root "public"
+                 :server-port 3449
+                 :css-dirs ["resources/public/css"]
+                 :ring-handler decktouch.handler/app}

-        :env {:dev? true}
+      :env {:dev? true}

-        :cljsbuild {
-          :builds {
-            :app {
-              :source-paths ["env/dev/cljs"]
-              :compiler {:output-to "resources/public/js/app.js"}}}}}
+      :cljsbuild {
+        :builds {
+          :app {
+            :source-paths ["env/dev/cljs"]
+            :compiler {:output-to "resources/public/js/app.js"}}}}}

     :uberjar {
       :hooks [leiningen.cljsbuild minify-assets.plugin/hooks]


Update lein-cloverage to 1.1.2

Update lein-cloverage to 1.1.2

--- project.clj
+++ project.clj
@@ -20,7 +20,7 @@
                    :plugins [[lein-binplus "0.6.5" :exclusions [org.clojure/clojure]]
                              [lein-codox "0.10.7"]
                              [lein-marginalia "0.9.1" :exclusions [org.clojure/clojure]]
-                             [lein-cloverage "1.1.1"]
+                             [lein-cloverage "1.1.2"]
                              [net.totakke/lein-libra "0.1.2"]]
                    :test-selectors {:default #(not-any? % [:slow :remote])
                                     :slow :slow ; Slow tests with local resources


Version 0.1.3

Version 0.1.3

--- project.clj
+++ project.clj
@@ -1,4 +1,4 @@
-(defproject clj-http-hystrix "0.1.3-SNAPSHOT"
+(defproject clj-http-hystrix "0.1.3"

   :description "A Clojure library to wrap clj-http requests as hystrix commands"
   :url "https://github.com/joelittlejohn/clj-http-hystrix"


Version 1.1.1-SNAPSHOT

Version 1.1.1-SNAPSHOT

--- project.clj
+++ project.clj
@@ -1,4 +1,4 @@
-(defproject puppetlabs/lein-ezbake "1.1.0"
+(defproject puppetlabs/lein-ezbake "1.1.1-SNAPSHOT"
   :description "A system for building packages for trapperkeeper-based applications"
   :url "https://github.com/puppetlabs/ezbake"
   :license {:name "Apache License 2.0"


Version 1.0.0-SNAPSHOT

Version 1.0.0-SNAPSHOT

--- project.clj
+++ project.clj
@@ -1,4 +1,4 @@
-(defproject pandect "0.6.2-SNAPSHOT"
+(defproject pandect "1.0.0-SNAPSHOT"
   :description "Message Digest and Checksum Library for Clojure"
   :url "https://github.com/xsc/pandect"
   :license {:name "MIT"


Use clojure 1.9-alpha15

Use clojure 1.9-alpha15

--- project.clj
+++ project.clj
@@ -1,5 +1,5 @@
 (defproject todomvc "0.0.0"
-  :dependencies [[org.clojure/clojure "1.8.0"]
+  :dependencies [[org.clojure/clojure "1.9.0-alpha15"]
                  [org.clojure/clojurescript "1.9.89"]
                  [com.cerner/clara-rules "0.13.0"]
                  [org.toomuchcode/clara-tools "0.1.1" :exclusions [org.toomuchcode/clara-rules]]


Fixed dependencies

Fixed dependencies

--- project.clj
+++ project.clj
@@ -32,28 +32,33 @@
   :dependencies [
                   [org.clojure/clojure     "1.6.0"]
                   [org.clojure/tools.nrepl "0.2.3"]
-                  [clj-http                       "0.9.2"           :scope "test"]
-                  [tk.skuro.alfresco/h2-support   "1.6"             :scope "test"]
-                  [com.h2database/h2              "1.3.174"         :scope "test"]
-                  [org.eclipse.jetty/jetty-runner "9.2.1.v20140609" :scope "test"]
+                  ; WARNING: do _not_ add test, provided or runtime dependencies here as they will be included in the uberjar,
+                  ; regardless of scope.  See https://github.com/technomancy/leiningen/issues/741 for an explanation of why
+                  ; this occurs.
                 ]
   :profiles {:dev      { :plugins [[lein-amp "0.3.0"]] }
              :uberjar  { :aot :all }
+             :test     { :dependencies [
+                                         [clj-http                       "0.9.2"           :scope "test"]
+                                         [tk.skuro.alfresco/h2-support   "1.6"             :scope "test"]
+                                         [com.h2database/h2              "1.3.174"         :scope "test"]
+                                         [org.eclipse.jetty/jetty-runner "9.2.1.v20140609" :scope "test"]
+                                       ] }
              :provided { :dependencies [
-                                         [org.alfresco/alfresco-core                            ~alfresco-version :scope "runtime"]
-                                         [org.alfresco/alfresco-data-model                      ~alfresco-version :scope "runtime"]
-                                         [org.alfresco/alfresco-mbeans                          ~alfresco-version :scope "runtime"]
-                                         [org.alfresco/alfresco-remote-api                      ~alfresco-version :scope "runtime"]
-                                         [org.alfresco/alfresco-repository                      ~alfresco-version :scope "runtime"]
-                                         [org.springframework/spring-context                    "3.0.5.RELEASE"   :scope "runtime"]
-                                         [org.springframework/spring-beans                      "3.0.5.RELEASE"   :scope "runtime"]
-                                         [org.springframework.extensions.surf/spring-webscripts "1.2.0"           :scope "runtime"]
+                                         [org.alfresco/alfresco-core                            ~alfresco-version :scope "provided"]
+                                         [org.alfresco/alfresco-data-model                      ~alfresco-version :scope "provided"]
+                                         [org.alfresco/alfresco-mbeans                          ~alfresco-version :scope "provided"]
+                                         [org.alfresco/alfresco-remote-api                      ~alfresco-version :scope "provided"]
+                                         [org.alfresco/alfresco-repository                      ~alfresco-version :scope "provided"]
+                                         [org.springframework/spring-context                    "3.0.5.RELEASE"   :scope "provided"]
+                                         [org.springframework/spring-beans                      "3.0.5.RELEASE"   :scope "provided"]
+                                         [org.springframework.extensions.surf/spring-webscripts "1.2.0"           :scope "provided"]
                                        ] }
             }
   :source-paths      ["src/clojure"]
   :java-source-paths ["src/java"]
   :resource-paths    ["src/resource"]
   :amp-source-path   "src/amp"
-  :amp-target-war    [org.alfresco/alfresco "4.2.c" :extension "war"]
+  :amp-target-war    [org.alfresco/alfresco alfresco-version :extension "war"]
   :javac-target      "1.7"
   )


remove marginalia for now

remove marginalia for now

--- project.clj
+++ project.clj
@@ -12,7 +12,7 @@
             (flare.clojure-test/install!)]
           :plugins [
                     ; documentation
-                    [lein-marginalia "0.8.1-SNAPSHOT"]
+                    ; [lein-marginalia "0.8.1-SNAPSHOT"]
                     ; interactive web REPL
                     [lein-gorilla "0.3.4"]
                     ; static code analysis


Austin repl support.

Austin repl support.

--- project.clj
+++ project.clj
@@ -2,7 +2,7 @@
   :description "FIXME: write this!"
   :url "http://example.com/FIXME"
   :dependencies [[org.clojure/clojure "1.5.1"]
-                 [org.clojure/clojurescript "0.0-2202"]
+                 [org.clojure/clojurescript "0.0-2234"]
                  [prismatic/dommy "0.1.2"]
                  [com.cemerick/url "0.1.1"]
                  [org.clojure/core.async "0.1.298.0-2a82a1-alpha"]
@@ -10,9 +10,10 @@
                  [ring "1.2.1"]]
   :plugins [[lein-cljsbuild "1.0.3"]
             [lein-ring "0.8.10"]]
+  :repl-options {:init-ns town-client.control}
   :jvm-opts ["-Xmx2g"]
   :hooks [leiningen.cljsbuild]
-  :source-paths ["src/clj"]
+  :source-paths ["src/clj" "src/cljs"]
   :cljsbuild {
     :builds {
       :main {


Version 1.0.2

Version 1.0.2

--- project.clj
+++ project.clj
@@ -1,4 +1,4 @@
-(defproject pandect "1.0.2-SNAPSHOT"
+(defproject pandect "1.0.2"
   :description "Message Digest and Checksum Library for Clojure"
   :url "https://github.com/xsc/pandect"
   :license {:name "MIT"


Changed war file name back as didn't fix relative path issue

--- project.clj
+++ project.clj
@@ -27,5 +27,5 @@
                       [lein-kibit "0.0.8"]
                       [jonase/eastwood "0.2.1"]]
             :ring {:handler      checkin.handler/app
-                   :uberwar-name "ROOT.war"}
+                   :uberwar-name "loneworkercheckin.war"}
             :aliases {"run-proxied" ["with-profile" "proxied" "ring" "server"]})


Deprecate version lacking group-id.

Deprecate version lacking group-id.

--- project.clj
+++ project.clj
@@ -10,8 +10,8 @@
 ;;; You must not remove this notice, or any other, from this software.

-(defproject muxx "0.1.2"
-  :description "Deploy multiple production and dev websites on one instance of compojure."
+(defproject muxx "0.1.3"
+  :description "DEPRECATED: Use degel/muxx. Deploy multiple production and dev websites on one instance of compojure."
   :url "https://github.com/deg/muxx"
   :license {:name "Eclipse Public License"
             :url "http://www.eclipse.org/legal/epl-v10.html"}


org.clojure/core.typed 0.2.84 released

org.clojure/core.typed 0.2.84 released

--- project.clj
+++ project.clj
@@ -22,7 +22,7 @@
                   :exclusions [instaparse]]
                  [cddr/integrity "0.3.0-SNAPSHOT"
                   :exclusions [org.clojure/clojure]]
-                 [org.clojure/core.typed "0.2.83"]
+                 [org.clojure/core.typed "0.2.84"]

                  ;; Crypto
                  [caesium "0.3.0"]


Upgrading kixi.comms to 0.2.18

Upgrading kixi.comms to 0.2.18

--- project.clj
+++ project.clj
@@ -33,7 +33,7 @@
                  [com.taoensso/encore "2.90.1"]
                  [digest "1.4.4"]
                  [environ "1.1.0"]
-                 [kixi/kixi.comms "0.2.17"]
+                 [kixi/kixi.comms "0.2.18"]
                  [kixi/kixi.log "0.1.4"]
                  [kixi/kixi.metrics "0.4.1"]
                  [kixi/joplin.core "0.3.10-SNAPSHOT"]


comment out closure-compiler until needed

--- project.clj
+++ project.clj
@@ -22,7 +22,7 @@
   :dependencies
   [[org.clojure/clojure "1.3.0"]
    [org.pegdown/pegdown "1.1.0"]
-   [com.google.javascript/closure-compiler "r1592"]
+   ;[com.google.javascript/closure-compiler "r1592"]
    [org.clojure/tools.cli "0.2.1"]]

   :main me.panzoo.story)


Back to snapshot.

Back to snapshot.

--- project.clj
+++ project.clj
@@ -1,4 +1,4 @@
-(defproject com.mdrogalis/onyx-kafka "0.6.0-alpha1"
+(defproject com.mdrogalis/onyx-kafka "0.6.0-SNAPSHOT"
   :description "Onyx plugin for Kafka"
   :url "https://github.com/MichaelDrogalis/onyx-kafka"
   :license {:name "Eclipse Public License"


Bump deps

Bump deps

--- project.clj
+++ project.clj
@@ -12,11 +12,11 @@

   :dependencies
   [[org.clojure/clojure         "1.4.0"]
-   [com.taoensso/encore         "1.15.0"]
+   [com.taoensso/encore         "1.16.0"]
    [com.taoensso/timbre         "3.3.1"]
    [com.taoensso/nippy          "2.7.0"]
    [org.apache.commons/commons-pool2 "2.2"]
-   [commons-codec/commons-codec "1.9"]
+   [commons-codec/commons-codec "1.10"]
    [org.clojure/data.json       "0.2.5"]]

   :profiles
@@ -25,7 +25,7 @@
    :1.5  {:dependencies [[org.clojure/clojure "1.5.1"]]}
    :1.6  {:dependencies [[org.clojure/clojure "1.6.0"]]}
    :test {:dependencies [[expectations            "2.0.13"]
-                         [org.clojure/test.check  "0.5.9"]
+                         [org.clojure/test.check  "0.6.1"]
                          [com.taoensso/faraday    "1.5.0"]
                          [clj-aws-s3              "0.3.10"]
                          [ring/ring-core          "1.3.1"]]


Don't dump heap on out of memory

Don't dump heap on out of memory

--- project.clj
+++ project.clj
@@ -49,7 +49,7 @@
              :find-atoms-in-dirs {:main atom-finder.find-atoms-in-dirs} ; https://stackoverflow.com/questions/11023762/leiningen-with-multiple-main-classes
              }
   :aliases {"find-atoms-in-dirs" ["with-profile" "find-atoms-in-dirs" "run"]}
-  :jvm-opts ["-Xss8m" "-Xmx8g" "-XX:+HeapDumpOnOutOfMemoryError"]
+  :jvm-opts ["-Xss8m" "-Xmx8g"]
   :main atom-finder.core
   ;:aot [atom-finder.core]
   :plugins [[lein-codox "0.10.3"]


Add primitive addicted parser

Add primitive addicted parser

--- project.clj
+++ project.clj
@@ -3,4 +3,16 @@
   :url "http://example.com/FIXME"
   :license {:name "Eclipse Public License"
             :url "http://www.eclipse.org/legal/epl-v10.html"}
-  :dependencies [[org.clojure/clojure "1.5.1"]])
+  :dependencies [[org.clojure/clojure "1.5.1"]
+                 [org.clojure/clojurescript "0.0-2138"]
+                 [compojure "1.1.6"]
+                 [lib-noir "0.7.9"]
+                 [hiccup "1.0.4"]
+                 [garden "1.1.4"]
+                 [im.chit/purnam "0.1.8"]
+                 [com.novemberain/monger "1.7.0-beta1"]
+                 [enlive "1.1.5"]
+                 [clj-http "0.7.8"]
+                 [lein-bower "0.1.0"]]
+  :profiles {:dev {:dependencies [[midje "1.6.0"]]}}
+  :bower {:directory "resources/public/"})


lein-release plugin: bumped version from 0.15 to 0.16-SNAPSHOT for next development cycle

--- project.clj
+++ project.clj
@@ -1,4 +1,4 @@
-(defproject tyranitar "0.15"
+(defproject tyranitar "0.16-SNAPSHOT"
   :description "Tyranitar service"
   :url "http://wikis.in.nokia.com/NokiaMusicArchitecture/Tyranitar"


Upgrade to 0.9.0-alpha12.

Upgrade to 0.9.0-alpha12.

--- project.clj
+++ project.clj
@@ -1,10 +1,10 @@
-(defproject workshop "0.8.11"
+(defproject workshop "0.9.0-alpha12"
   :license {:name "Eclipse Public License"
             :url "http://www.eclipse.org/legal/epl-v10.html"}
   :dependencies [[org.clojure/clojure "1.7.0"]
                  [org.clojure/core.async "0.2.374"]
                  ^{:voom {:repo "git@github.com:onyx-platform/onyx.git" :branch "master"}}
-                 [org.onyxplatform/onyx "0.8.11"]
+                 [org.onyxplatform/onyx "0.9.0-alpha12"]
                  [org.slf4j/slf4j-api "1.7.12"]
                  [org.slf4j/slf4j-nop "1.7.12"]]
   :profiles {:dev {:dependencies [[org.clojure/tools.namespace "0.2.10"]


Set clj-parent=4.6.10

Set clj-parent=4.6.10

--- project.clj
+++ project.clj
@@ -27,7 +27,7 @@

   :min-lein-version "2.9.1"

-  :parent-project {:coords [puppetlabs/clj-parent "4.6.9"]
+  :parent-project {:coords [puppetlabs/clj-parent "4.6.10"]
                    :inherit [:managed-dependencies]}

   :dependencies [[org.clojure/clojure]


fixed project version

fixed project version

--- project.clj
+++ project.clj
@@ -1,4 +1,4 @@
-(defproject pe-datomic-utils "SNAPSHOT-0.0.8"
+(defproject pe-datomic-utils "0.0.8-SNAPSHOT"
   :description "A Clojure library of helper functions when working with Datomic."
   :url "https://github.com/evanspa/pe-datomic-utils"
   :license {:name "MIT"


tagged versions

tagged versions

--- project.clj
+++ project.clj
@@ -4,5 +4,5 @@
   :license {:name "Eclipse Public License"
             :url "http://www.eclipse.org/legal/epl-v10.html"}
   :dependencies [[org.clojure/clojure "1.7.0-beta2"]
-                 [org.clojure/clojurescript "0.0-3211"]
-                 [kovasb/gamma "0.1.1"]])
+                 [org.clojure/clojurescript "0.0-3291"]
+                 [kovasb/gamma "0.0-135"]])


Move project into the mixradio group

Move project into the mixradio group

--- project.clj
+++ project.clj
@@ -1,4 +1,4 @@
-(defproject mr-clojure/lein-template "1.0.2-SNAPSHOT"
+(defproject mixradio/mr-clojure "1.0.2-SNAPSHOT"
   :description "MixRadio clojure skeleton template for Leiningen. Generates a Clojure HTTP REST service in the style of MixRadio"
   :url "http://github.com/mixradio/mr-clojure"
   :eval-in-leiningen true


Removed duplicate dependency entry for com.lemonodor/xio.

--- project.clj
+++ project.clj
@@ -5,7 +5,6 @@
   :dependencies [[com.lemonodor/xio "0.2.2"]
                  [de.kotka/lazymap "3.1.1"]
                  [gloss "0.2.4"]
-                 [com.lemonodor/xio "0.2.2"]
                  [org.clojure/clojure "1.6.0"]
                  [org.clojure/tools.logging "0.3.1"]]
   :profiles {:dev {:dependencies [[criterium "0.4.3"]


version bump

version bump

--- project.clj
+++ project.clj
@@ -3,8 +3,8 @@
   :url "https://github.com/fredokun/LaTTe.git"
   :license {:name "MIT Licence"
             :url "http://opensource.org/licenses/MIT"}
-  :dependencies [[org.clojure/clojure "1.6.0"]]
-  :plugins [[cider/cider-nrepl "0.9.0-SNAPSHOT"]]
+  :dependencies [[org.clojure/clojure "1.7.0"]]
+  :plugins [[cider/cider-nrepl "0.10.0-SNAPSHOT"]]
   :main ^:skip-aot latte.core
   :target-path "target/%s"
   :profiles {:uberjar {:aot :all}})


Upgrade lein-shadow to 0.2.0

Upgrade lein-shadow to 0.2.0

--- project.clj
+++ project.clj
@@ -12,7 +12,7 @@
                  [re-frame                  "0.12.0" :scope "provided"]]

   :plugins      [[day8/lein-git-inject "0.0.11"]
-                 [lein-shadow          "0.1.7"]]
+                 [lein-shadow          "0.2.0"]]

   :middleware   [leiningen.git-inject/middleware]


bump version

bump version

--- project.clj
+++ project.clj
@@ -1,5 +1,5 @@
-(defproject tracks "1.0.5"
-  :description "Example based function generation"
+(defproject tracks "1.0.6"
+  :description "Shape based programming"
   :url "https://github.com/escherize/tracks"
   :license {:name "Eclipse Public License"
             :url "http://www.eclipse.org/legal/epl-v10.html"}


0.1.1

--- project.clj
+++ project.clj
@@ -1,5 +1,5 @@
-(defproject ansel "0.1.0"
-  :description "FIXME: write description"
+(defproject ansel "0.1.1"
+  :description "Ansel, a self-hosted photo gallery"
   :url "http://example.com/FIXME"
   :dependencies [[org.clojure/clojure "1.5.1"]
                  [compojure "1.1.5"]


Upgrade kixi.comms 31

Upgrade kixi.comms 31

--- project.clj
+++ project.clj
@@ -33,7 +33,7 @@
                  [com.taoensso/encore "2.92.0"]
                  [digest "1.4.6"]
                  [environ "1.1.0"]
-                 [kixi/kixi.comms "0.2.30"]
+                 [kixi/kixi.comms "0.2.31"]
                  [kixi/kixi.log "0.1.5"]
                  [kixi/kixi.metrics "0.4.1"]
                  [kixi/joplin.core "0.3.10-SNAPSHOT"]


start working on 0.6.1-SNAPSHOT

start working on 0.6.1-SNAPSHOT

--- project.clj
+++ project.clj
@@ -1,4 +1,4 @@
-(defproject chrisbetz/flambo "0.6.0"
+(defproject chrisbetz/flambo "0.6.1-SNAPSHOT"
             :description "A Clojure DSL for Apache Spark"
             :url "https://github.com/chrisbetz/flambo"
             :license {:name "Eclipse Public License"


Prepare for next release cycle.

Prepare for next release cycle.

--- project.clj
+++ project.clj
@@ -1,4 +1,4 @@
-(defproject org.onyxplatform/onyx-sql "0.7.10"
+(defproject org.onyxplatform/onyx-sql "0.7.11-SNAPSHOT"
   :description "Onyx plugin for JDBC-backed SQL databases"
   :url "https://github.com/MichaelDrogalis/onyx-sql"
   :license {:name "Eclipse Public License"


Version 0.8.0

Version 0.8.0

--- project.clj
+++ project.clj
@@ -3,7 +3,7 @@
 (def i18n-version "0.4.1")
 (def http-async-client-version "0.6.1")

-(defproject puppetlabs/pcp-broker "0.8.0-SNAPSHOT"
+(defproject puppetlabs/pcp-broker "0.8.0"
   :description "PCP fabric messaging broker"
   :url "https://github.com/puppetlabs/pcp-broker"
   :license {:name "Apache License, Version 2.0"


release 0.2.1

release 0.2.1

--- project.clj
+++ project.clj
@@ -1,4 +1,4 @@
-(defproject minhtuannguyen/remote-test-refresh "0.2.1-SNAPSHOT"
+(defproject minhtuannguyen/remote-test-refresh "0.2.1"
   :description "Automatically synchronize with remote project over ssh  when files change"
   :url "https://github.com/minhtuannguyen/remote-test-refresh"
   :license {:name "Eclipse Public License" :url "http://www.eclipse.org/legal/epl-v10.html"}


updated clojurescript dep and daaaaaaaaaaammmmmmmmmmnnnnnnnnn......

--- project.clj
+++ project.clj
@@ -20,7 +20,7 @@
                  [ring/ring-devel "1.3.2"]
                  [ring-partial-content "1.0.0"]
                  [compojure "1.3.2"]
-                 [org.clojure/clojurescript "0.0-3053"]
+                 [org.clojure/clojurescript "0.0-3058"]
                  [org.clojure/java.jdbc "0.3.6"]
                  [org.xerial/sqlite-jdbc "3.8.7"]
                  [org/jaudiotagger "2.0.3"]


Add todo

Add todo

--- project.clj
+++ project.clj
@@ -25,6 +25,7 @@
                  [com.palletops/thread-expr "1.3.0"]
                  [ns-tracker "0.2.2"]
                  [tinter "0.1.1-SNAPSHOT"]
+                 ;; TODO: point to fork
                  [clj-tiny-astar "0.1.1-SNAPSHOT"]
                  [dorothy "0.0.6"]
                  [shodan "0.4.1"]


(PDB-3077) Bump lein-ezbake dep to 1.1.3

This commit bumps the lein-ezbake plugin dependency from 1.1.2
to 1.1.3.  This change re-adds the XXOutOfMemoryError java
command line arg which had unintentionally been dropped as part
of the ezbake bump for service reload functionality done for
PDB-3077.

--- project.clj
+++ project.clj
@@ -143,7 +143,7 @@
              :ezbake {:dependencies ^:replace [[puppetlabs/puppetdb ~pdb-version]
                                                [org.clojure/tools.nrepl "0.2.3"]]
                       :name "puppetdb"
-                      :plugins [[puppetlabs/lein-ezbake "1.1.2"
+                      :plugins [[puppetlabs/lein-ezbake "1.1.3"
                                  :exclusions [org.clojure/clojure]]]}
              :testutils {:source-paths ^:replace ["test"]}
              :ci {:plugins [[lein-pprint "1.1.1"]]}}


Bump sente and immutant versions

Bump sente and immutant versions

--- project.clj
+++ project.clj
@@ -38,7 +38,9 @@
   :dependencies [[org.clojure/clojure "1.7.0"] ; absolutely should not need this
                  ;; Probably only useful server-side
                  [com.cognitect/transit-clj "0.8.275"]
-                 [org.immutant/immutant "2.0.2" :exclusions [clj-tuple
+                 ;; TODO: How many of these exclusions are still needed?
+                 ;; And do more get added w/ this version bump?
+                 [org.immutant/immutant "2.1.0" :exclusions [clj-tuple
                                                              org.clojure/clojure
                                                              org.clojure/java.classpath
                                                              org.clojure/tools.reader
@@ -81,7 +83,7 @@
                  #_[cider/cider-nrepl "0.9.1"]  ; definitely should not need to do this
                  ;; Really should inherit my clojure version from this.
                  [com.frereth/client "0.1.0-SNAPSHOT"]
-                 [com.taoensso/sente "1.6.0" :exclusions [org.clojure/clojure
+                 [com.taoensso/sente "1.7.0-RC1" :exclusions [org.clojure/clojure
                                                           org.clojure/tools.reader]]
                  ;; Shouldn't need this here, but it isn't being picked up in my profile
                  [figwheel "0.3.7" :exclusions [cider/cider-nrepl


Version 5.1.7-SNAPSHOT

Version 5.1.7-SNAPSHOT

--- project.clj
+++ project.clj
@@ -1,4 +1,4 @@
-(def ps-version "5.1.6")
+(def ps-version "5.1.7-SNAPSHOT")
 (def jruby-1_7-version "1.7.27-1")
 (def jruby-9k-version "9.1.11.0-1")


Install cloverage

Install cloverage

--- project.clj
+++ project.clj
@@ -9,7 +9,8 @@
                  [fipp "0.6.8"]
                  [spectrace "0.1.0-SNAPSHOT"]]

-  :plugins [[lein-cljsbuild "1.1.4"]
+  :plugins [[lein-cloverage "1.0.9"]
+            [lein-cljsbuild "1.1.4"]
             [lein-eftest "0.3.1"]]

   :cljsbuild


Upgrade prismatic/schema

Upgrade prismatic/schema

--- project.clj
+++ project.clj
@@ -16,7 +16,7 @@
                  [http-kit "2.1.19"]

                  ;; Schemata
-                 [prismatic/schema "0.3.0"]
+                 [prismatic/schema "0.3.3"]
                  [schema-contrib "0.1.5"]
                  [cddr/integrity "0.2.0-20140823.193326-1" :exclusions [org.clojure/clojure]]


Update dependency.

Update dependency.

--- project.clj
+++ project.clj
@@ -29,7 +29,7 @@
                  [ola-clojure "0.1.8-SNAPSHOT" :exclusions [org.clojure/tools.reader]]
                  [selmer "1.0.7" :exclusions [cheshire]]
                  [com.evocomputing/colors "1.0.3"]
-                 [environ "1.0.3"]
+                 [environ "1.1.0"]
                  [camel-snake-kebab "0.4.0"]
                  [com.taoensso/timbre "4.7.4"]
                  [com.fzakaria/slf4j-timbre "0.3.2"]


Version 0.0.33-SNAPSHOT

Version 0.0.33-SNAPSHOT

--- project.clj
+++ project.clj
@@ -1,4 +1,4 @@
-(defproject pe-fp-core "0.0.32"
+(defproject pe-fp-core "0.0.33-SNAPSHOT"
   :description "A Clojure library encapsulating the various domain objects associated with the Gas Jot application."
   :url "https://github.com/evanspa/pe-fp-core"
   :license {:name "MIT"


Increase version to 0.9.9

Increase version to 0.9.9

--- project.clj
+++ project.clj
@@ -4,7 +4,7 @@
                     (System/getenv "TRAVIS_COMMIT")))
 (def app-url (or (System/getenv "APP_URL") ""))

-(defproject qu "0.9.8"
+(defproject qu "0.9.9"
   :description "qu is an **in-progress** data platform created by the CFPB to
 serve their public data sets."
   :build-number ~build-number


Update dependencies

Update dependencies

--- project.clj
+++ project.clj
@@ -6,14 +6,14 @@
   :dependencies [[bidi "1.10.5"]
                  [org.clojure/clojure "1.6.0"]
                  [org.clojure/java.jdbc "0.3.6"]
-                 [hikari-cp "0.9.0"]
+                 [hikari-cp "0.9.1"]
                  [liberator "0.12.2"]
                  [postgresql "9.3-1102.jdbc41"]
                  [prone "0.6.0"]
                  [ring/ring-anti-forgery "1.0.0"]
                  [dhruv/ring-secure-headers "0.3.0"]
                  [org.clojure/tools.logging "0.3.1"]
-                 [puppetlabs/trapperkeeper "0.5.1"]
+                 [puppetlabs/trapperkeeper "0.5.2"]
                  [puppetlabs/trapperkeeper-webserver-jetty9 "0.9.0"]
                  [yesql "0.4.0"]]
   :profiles {:dev {:dependencies [[org.clojure/tools.namespace "0.2.7"]]}}


Version 2.17.4 [ci skip]

Version 2.17.4 [ci skip]

--- project.clj
+++ project.clj
@@ -1,4 +1,4 @@
-(defproject clojush "2.17.3-1-SNAPSHOT"
+(defproject clojush "2.17.4"
   :description "The Push programming language and the PushGP genetic programming
                 system implemented in Clojure. See http://pushlanguage.com"
   :license {:name "Eclipse Public License"


release 0.1.7

release 0.1.7

--- project.clj
+++ project.clj
@@ -1,4 +1,4 @@
-(defproject minhtuannguyen/remote-test-refresh "0.1.7-SNAPSHOT"
+(defproject minhtuannguyen/remote-test-refresh "0.1.7"
   :description "Automatically synchronize with remote project over ssh  when files change"
   :url "https://github.com/minhtuannguyen/remote-test-refresh"
   :license {:name "Eclipse Public License" :url "http://www.eclipse.org/legal/epl-v10.html"}


Kafka extension removed from the main artifact temporarily

--- project.clj
+++ project.clj
@@ -18,9 +18,9 @@
             [jonase/eastwood "0.2.7"]
             [lein-bikeshed "0.5.1"]]

-  :sub ["core" "i18n" "http"
+  :sub ["core" "i18n" "http"]
         ;;"extra_components/kafka"
-        ]
+

   :deploy-repositories [["releases" :clojars]


Update dependencies

Update dependencies

--- project.clj
+++ project.clj
@@ -9,11 +9,11 @@
   :hooks [leiningen.cljsbuild]

   :dependencies [[org.clojure/clojure "1.9.0-alpha17"]
-                 [org.clojure/clojurescript "1.9.854"]
+                 [org.clojure/clojurescript "1.9.908"]
                  [org.clojure/core.async "0.3.443" :exclusions [org.clojure/tools.reader]]
                  [org.clojure/test.check "0.9.0"]
                  [org.omcljs/om "1.0.0-alpha48"]
-                 [cljs-ajax "0.6.0"]
+                 [cljs-ajax "0.7.2"]
                  [com.cognitect/transit-cljs "0.8.239"]
                  [lein-doo "0.1.7"]  ;; <-- otherwise it won't find the doo namespaces...
                  [devcards "0.2.3"]
@@ -24,7 +24,7 @@
             [lein-cljsbuild "1.1.5" :exclusions [[org.clojure/clojure]]]
             [lein-codox "0.10.3"]
             [lein-doo "0.1.7"]
-            [lein-figwheel "0.5.13-SNAPSHOT"]
+            [lein-figwheel "0.5.13"]
             [lein-kibit "0.1.3"]
             [lein-set-version "0.4.1"]]

@@ -36,7 +36,7 @@
             "build" ["do" "clean" ["cljsbuild" "once" "min"]]}

   :profiles {:dev {:dependencies [[binaryage/devtools "0.9.4"]
-                                  [figwheel-sidecar "0.5.13-SNAPSHOT"]
+                                  [figwheel-sidecar "0.5.13"]
                                   [com.cemerick/piggieback "0.2.2"]]
                    ;; need to add dev source path here to get user.clj loaded
                    :source-paths ["src/discuss"]


0.0.3

--- project.clj
+++ project.clj
@@ -1,4 +1,4 @@
-(defproject react-native-externs "0.0.2-SNAPSHOT"
+(defproject react-native-externs "0.0.3"
   :description "Google Closure extern files for React Native itself and for the libraries around it"
   :url "https://github.com/artemyarulin/react-native-externs"
   :license {:name "MIT License"


Update lib version to make sure the read data are retrieved as needed.

--- project.clj
+++ project.clj
@@ -38,7 +38,7 @@
     [zprint "0.5.3"]

     ;; Library for OC projects https://github.com/open-company/open-company-lib
-    [open-company/lib "0.17.25-alpha8"]
+    [open-company/lib "0.17.25.2-alpha2"]
     ;; In addition to common functions, brings in the following common dependencies used by this project:
     ;; httpkit - HTTP client/server http://www.http-kit.org/
     ;; defun - Erlang-esque pattern matching for Clojure functions https://github.com/killme2008/defun


Increase repl timeout

Increase repl timeout

--- project.clj
+++ project.clj
@@ -24,4 +24,5 @@
   :aot [cider-ci.repository.main]
   :main cider-ci.repository.main
   :jvm-opts ["-Xmx256m"]
+  :repl-options {:timeout  120000}
   )


Move to plaintext for retrieving dataomic-pro.

--- project.clj
+++ project.clj
@@ -7,8 +7,7 @@
   :source-paths ["src/clj" "src/cljs"]
   :resource-paths ["resources"]

-  :repositories {"my.datomic.com" {:url "https://my.datomic.com/repo"
-                                   :creds :gpg}}
+  :repositories {"my.datomic.com" {:url "https://my.datomic.com/repo"}}

   :dependencies [[org.clojure/clojure "1.6.0"]
                  [org.clojure/clojurescript "0.0-2356"]


Re-format project.clj.

Re-format project.clj.

--- project.clj
+++ project.clj
@@ -18,37 +18,30 @@
                                          "default,hadoop-cdh3:"
                                          "default,hadoop-cdh4")
                     ,              "test"]}
-  :profiles {:provided
-             {:dependencies
-              [[org.codehaus.jsr166-mirror/jsr166y "1.7.0"]
-               [org.apache.hadoop/hadoop-core "1.2.1"]
-               [log4j "1.2.17"]]}
-             :hadoop-0-20-2
-             {:dependencies
-              [[org.apache.hadoop/hadoop-core "0.20.2"]]}
-             :hadoop-0-20-205
-             {:dependencies
-              [[org.apache.hadoop/hadoop-core "0.20.205.0"]]}
-             :hadoop-1-0-3
-             {:dependencies
-              [[org.apache.hadoop/hadoop-core "1.0.3"]]}
-             :hadoop-1-2-1
-             {:dependencies
-              [[org.apache.hadoop/hadoop-core "1.2.1"]]}
-             :hadoop-cdh3
-             {:repositories
-              [["cloudera" ~(str "https://repository.cloudera.com"
-                                 "/artifactory/cloudera-repos/")]]
-              :dependencies
-              [[org.apache.hadoop/hadoop-core "0.20.2-cdh3u3"]]}
-             :hadoop-cdh4
-             {:repositories
-              [["cloudera" ~(str "https://repository.cloudera.com"
-                                 "/artifactory/cloudera-repos/")]
-               ["damballa" "http://jars.repo.rnd.atl.damballa/"]]
-              :dependencies
-              [[org.apache.hadoop/hadoop-core "2.0.0-mr1-cdh4.1.2"]
-               [org.apache.hadoop/hadoop-common "2.0.0-cdh4.1.2"]
-               [org.apache.avro/avro-mapred "1.7.5"
-                :classifier "hadoop1-cdh4"
-                :exclusions [org.apache.avro/avro-ipc]]]}})
+  :profiles {:provided {:dependencies
+                        [[org.codehaus.jsr166-mirror/jsr166y "1.7.0"]
+                         [org.apache.hadoop/hadoop-core "1.2.1"]
+                         [log4j "1.2.17"]]}
+             :hadoop-0-20-2 {:dependencies
+                             [[org.apache.hadoop/hadoop-core "0.20.2"]]}
+             :hadoop-0-20-205 {:dependencies
+                               [[org.apache.hadoop/hadoop-core "0.20.205.0"]]}
+             :hadoop-1-0-3 {:dependencies
+                            [[org.apache.hadoop/hadoop-core "1.0.3"]]}
+             :hadoop-1-2-1 {:dependencies
+                            [[org.apache.hadoop/hadoop-core "1.2.1"]]}
+             :hadoop-cdh3 {:repositories
+                           [["cloudera" ~(str "https://repository.cloudera.com"
+                                              "/artifactory/cloudera-repos/")]]
+                           :dependencies
+                           [[org.apache.hadoop/hadoop-core "0.20.2-cdh3u3"]]}
+             :hadoop-cdh4 {:repositories
+                           [["cloudera" ~(str "https://repository.cloudera.com"
+                                              "/artifactory/cloudera-repos/")]
+                            ["damballa" "http://jars.repo.rnd.atl.damballa/"]]
+                           :dependencies
+                           [[org.apache.hadoop/hadoop-core "2.0.0-mr1-cdh4.1.2"]
+                            [org.apache.hadoop/hadoop-common "2.0.0-cdh4.1.2"]
+                            [org.apache.avro/avro-mapred "1.7.5"
+                             :classifier "hadoop1-cdh4"
+                             :exclusions [org.apache.avro/avro-ipc]]]}})


Version 5.3.4-SNAPSHOT

Version 5.3.4-SNAPSHOT

--- project.clj
+++ project.clj
@@ -1,4 +1,4 @@
-(def ps-version "5.3.3")
+(def ps-version "5.3.4-SNAPSHOT")
 (def jruby-1_7-version "1.7.27-1")
 (def jruby-9k-version "9.1.16.0-1")


Cassandra driver core 2.0.2

Cassandra driver core 2.0.2

--- project.clj
+++ project.clj
@@ -7,7 +7,7 @@
   :dependencies [[org.clojure/clojure                          "1.6.0"]
                  [cc.qbits/hayt                                "1.4.1"
                   :exclusions [org.flatland/useful]]
-                 [com.datastax.cassandra/cassandra-driver-core "2.0.1"]]
+                 [com.datastax.cassandra/cassandra-driver-core "2.0.2"]]
   :source-paths      ["src/clojure"]
   :java-source-paths ["src/java"]
   :profiles       {:1.4 {:dependencies [[org.clojure/clojure "1.4.0"]]}


Added core.async dep for streaming.

Added core.async dep for streaming.

--- project.clj
+++ project.clj
@@ -34,6 +34,7 @@
     [metosin/reitit-ring "0.1.1-SNAPSHOT"]
     [metosin/ring-http-response "0.9.0"]
     [org.clojure/clojure "1.9.0"]
+    [org.clojure/core.async "0.4.474"]
     [org.clojure/core.cache "0.7.1"]
     [org.clojure/data.xml "0.2.0-alpha5"]
     [ring/ring-core "1.6.3"]


Version 0.5.10-SNAPSHOT

Version 0.5.10-SNAPSHOT

--- project.clj
+++ project.clj
@@ -1,4 +1,4 @@
-(defproject yetibot.core "0.5.9"
+(defproject yetibot.core "0.5.10-SNAPSHOT"
   :description "Core yetibot utilities, extracted for shared use among yetibot
                 and its various plugins"
   :url "https://github.com/yetibot/yetibot.core"


(maint) Update to ezbake 1.6.2

(maint) Update to ezbake 1.6.2

--- project.clj
+++ project.clj
@@ -175,7 +175,7 @@
                                                [puppetlabs/puppetdb ~pdb-version]
                                                [org.clojure/tools.nrepl nil]]
                       :name "puppetdb"
-                      :plugins [[puppetlabs/lein-ezbake "1.5.1"]]}
+                      :plugins [[puppetlabs/lein-ezbake "1.6.2"]]}
              :testutils {:source-paths ^:replace ["test"]}
              :ci {:plugins [[lein-pprint "1.1.1"]]}
              :test {:jvm-opts ~(if need-permgen?


fix :repositories

fix :repositories

--- project.clj
+++ project.clj
@@ -2,6 +2,7 @@
   :source-path "src/clj"
   :java-source-path "src/jvm"
   :javac-options {:debug "true" :fork "true"}
+  :repositories {"spy" "http://files.couchbase.com/maven2"}

   :dependencies [[spy/spymemcached "2.8.1"]
                  [com.thimbleware.jmemcached/jmemcached-cli "1.0.0"]


Release 0.41.0.

Release 0.41.0.

--- project.clj
+++ project.clj
@@ -6,7 +6,7 @@
 ;;   the terms of this license.
 ;;   You must not remove this notice, or any other, from this software.

-(defproject uncomplicate/neanderthal "0.41.0-SNAPSHOT"
+(defproject uncomplicate/neanderthal "0.41.0"
   :description "Neanderthal is a Clojure library for fast matrix and linear algebra computations."
   :url "https://github.com/uncomplicate/neanderthal"
   :scm {:name "git"
@@ -19,7 +19,7 @@
                  [uncomplicate/neanderthal-native "0.33.0"]
                  [uncomplicate/clojurecl "0.15.0"]
                  [org.jocl/jocl-blast "1.5.2"]
-                 [uncomplicate/clojurecuda "0.13.0-SNAPSHOT"]
+                 [uncomplicate/clojurecuda "0.13.0"]
                  [org.jcuda/jcublas "11.2.0"]
                  [org.apache.commons/commons-math3 "3.6.1"]]


supernal 0.2.2

supernal 0.2.2

--- project.clj
+++ project.clj
@@ -30,7 +30,7 @@
                  [metrics-clojure-ring "0.9.2"]
                  [ch.qos.logback/logback-classic "1.0.9"]
                  [org.codehaus.groovy/groovy "2.1.2"]
-                 [supernal "0.2.1"]
+                 [supernal "0.2.2"]
                  [ring "1.1.8"]
                  [compojure "1.1.5" :exclusions  [ring/ring-core]]
                  [ring/ring-jetty-adapter "1.1.8"]


1.3.0

--- project.clj
+++ project.clj
@@ -1,4 +1,4 @@
-(defproject org.roman01la/cljss "1.2.0"
+(defproject org.roman01la/cljss "1.3.0"
   :description "Clojure Style Sheets"
   :url "https://github.com/roman01la/cljss"
   :license {:name "Eclipse Public License"


CMR-5192: Bumped microversion and updated deps.

--- project.clj
+++ project.clj
@@ -14,7 +14,7 @@
        ns
        "\u001B[35m]\u001B[33m λ\u001B[m=> "))

-(defproject gov.nasa.earthdata/cmr-exchange-common "0.2.0-SNAPSHOT"
+(defproject gov.nasa.earthdata/cmr-exchange-common "0.2.1-SNAPSHOT"
   :description "Cross-project functionality, utilities, and general-use components"
   :url "https://github.com/cmr-exchange/cmr-exchange-common"
   :license {
@@ -22,7 +22,7 @@
     :url "http://www.apache.org/licenses/LICENSE-2.0"}
   :dependencies [
     [clojusc/results "0.1.0"]
-    [clojusc/trifl "0.4.0"]
+    [clojusc/trifl "0.4.2"]
     [clojusc/twig "0.4.0"]
     [org.clojure/clojure "1.9.0"]]
   :aot [clojure.tools.logging.impl]