Improve REPL pane behavior

Improve REPL pane behavior

--- src/clojure/nightcode/editors.clj
+++ src/clojure/nightcode/editors.clj
@@ -264,35 +264,36 @@
     (when enable-advanced? toggle-paredit-fn!)))

 (defn add-watchers!
-  ([path text-area completer]
-    (let [extension (utils/get-extension path)
-          clojure? (contains? clojure-exts extension)]
-      (add-watch font-size
+  [path extension text-area completer]
+  (let [exists? (.exists (io/file path))
+        clojure? (contains? clojure-exts extension)]
+    (add-watch font-size
+               (utils/hashed-keyword path)
+               (fn [_ _ _ x]
+                 (set-font-size! text-area x)))
+    (when-let [toggle-paredit-fn! (init-paredit! text-area exists? clojure?)]
+      (add-watch paredit-enabled?
                  (utils/hashed-keyword path)
-                 (fn [_ _ _ x]
-                   (set-font-size! text-area x)))
-      (when-let [toggle-paredit-fn! (init-paredit! text-area clojure? clojure?)]
-        (add-watch paredit-enabled?
-                   (utils/hashed-keyword path)
-                   (fn [_ _ _ enable?]
-                     (toggle-paredit-fn! enable?))))
-      (when completer
-        (add-watch doc-enabled?
-                   (utils/hashed-keyword path)
-                   (fn [_ _ _ enable?]
-                     (.setAutoActivationEnabled completer enable?))))))
-  ([path text-area completer pane]
-    (add-watchers! path text-area completer)
-    (add-watch paredit-enabled?
-               (utils/hashed-keyword (str "button:" path))
-               (fn [_ _ _ enable?]
-                 (some-> (s/select pane [:#paredit])
-                         (s/config! :selected? enable?))))
-    (add-watch doc-enabled?
-               (utils/hashed-keyword (str "button:" path))
-               (fn [_ _ _ enable?]
-                 (some-> (s/select pane [:#doc])
-                         (s/config! :selected? enable?))))))
+                 (fn [_ _ _ enable?]
+                   (toggle-paredit-fn! enable?))))
+    (when completer
+      (add-watch doc-enabled?
+                 (utils/hashed-keyword path)
+                 (fn [_ _ _ enable?]
+                   (.setAutoActivationEnabled completer enable?))))))
+
+(defn add-button-watchers!
+  [path pane]
+  (add-watch paredit-enabled?
+             (utils/hashed-keyword (str "button:" path))
+             (fn [_ _ _ enable?]
+               (some-> (s/select pane [:#paredit])
+                       (s/config! :selected? enable?))))
+  (add-watch doc-enabled?
+             (utils/hashed-keyword (str "button:" path))
+             (fn [_ _ _ enable?]
+               (some-> (s/select pane [:#doc])
+                         (s/config! :selected? enable?)))))

 (defn remove-watchers!
   [path]
@@ -407,7 +408,7 @@
   ([path extension]
     (let [text-area (create-text-area)
           completer (create-completer text-area extension)]
-      (add-watchers! path text-area completer)
+      (add-watchers! path extension text-area completer)
       (doto text-area
         (.setSyntaxEditingStyle (get utils/styles extension))
         (.setLineWrap true)
@@ -558,7 +559,8 @@
                 :key-released
                 (fn [e] (update-buttons! editor-pane text-area)))
       ; add watchers
-      (add-watchers! path text-area completer editor-pane)
+      (add-watchers! path extension text-area completer)
+      (add-button-watchers! path editor-pane)
       ; install completer if it exists
       (some->> completer (install-completer! text-area))
       ; enable/disable buttons while typing


actx-event helper macro.

actx-event helper macro.

--- src/cbfg/ago.clj
+++ src/cbfg/ago.clj
@@ -4,13 +4,15 @@
 (defmacro actx-top [actx]
   `(first ~actx))

+(defmacro actx-event [actx event]
+  (cljs.core.async/>! (:event-ch (actx-top ~actx)) ~event))
+
 (defmacro ago [child-actx-binding-name actx & body]
   `(let [w# (actx-top ~actx)
          ago-id# (swap! (:last-id w#) inc)
          ~child-actx-binding-name (conj ~actx
                                         ['~child-actx-binding-name ago-id#])]
-     (go (cljs.core.async/>! (:event-ch (actx-top ~actx))
-                             ["ago" ~child-actx-binding-name])
+     (go (actx-event ~actx ["ago" ~child-actx-binding-name])
          ~@body)))

 (defmacro ago-loop [child-actx-binding-name actx bindings & body]
@@ -30,18 +32,18 @@

 (defmacro aclose [actx ch]
   `(let [w# (actx-top ~actx)]
-     (cljs.core.async/>! (:event-ch w#) ["aclose" ~actx ~ch])
+     (actx-event ~actx ["aclose" ~actx ~ch])
      (swap! (:chs w#) dissoc ch#)
      (cljs.core.async/close! ~ch)))

 (defmacro atake [actx ch]
-  `(do (cljs.core.async/>! (:event-ch (actx-top ~actx)) ["atake" ~actx ~ch])
+  `(do (actx-event ~actx ["atake" ~actx ~ch])
        (cljs.core.async/<! ~ch)))

 (defmacro aput [actx ch msg]
-  `(do (cljs.core.async/>! (:event-ch (actx-top ~actx)) ["aput" ~actx ~msg])
+  `(do (actx-event ~actx ["aput" ~actx ~msg])
        (cljs.core.async/>! ~ch ~msg)))

 (defmacro aalts [actx chs]
-  `(do (cljs.core.async/>! (:event-ch (actx-top ~actx)) ["aalts" ~actx ~chs])
+  `(do (actx-event ~actx ["aalts" ~actx ~chs])
        (cljs.core.async/alts! ~chs)))


Remove redundant namespace qualifiers

Remove redundant namespace qualifiers

Signed-off-by: Deepak Giridharagopal <d11186354d1ef01ca06ae37d7e23e827da13e85f@puppetlabs.com>

--- src/com/puppetlabs/cmdb/query.clj
+++ src/com/puppetlabs/cmdb/query.clj
@@ -4,8 +4,8 @@
             [com.puppetlabs.cmdb.query.resource :as resource]))

 (def routes
-  {"/resources"   com.puppetlabs.cmdb.query.resource/resource-list-handler
-   "/facts/:node" com.puppetlabs.cmdb.query.facts/fact-set-handler})
+  {"/resources"   resource/resource-list-handler
+   "/facts/:node" facts/fact-set-handler})

 (defn wrap-with-globals
   "Ring middleware that will add to each request a :globals attribute:


Distinguish between constant and conditional increases to rez cost.

E.g., Xanadu vs. Reina.

Support retrieving identities with (get-card).

--- src/clj/game/core.clj
+++ src/clj/game/core.clj
@@ -100,14 +100,16 @@
        (gain state :runner :memory mu))
      c)))

-(defn get-card [state {:keys [cid zone side host] :as card}]
-  (if zone
-    (if host
-      (let [h (get-card state host)]
-        (some #(when (= cid (:cid %)) %) (:hosted h)))
-      (some #(when (= cid (:cid %)) %)
-            (get-in @state (cons (to-keyword side) (map to-keyword zone)))))
-    card))
+(defn get-card [state {:keys [cid zone side host type] :as card}]
+  (if (= type "Identity")
+    (get-in @state [(to-keyword side) :identity])
+    (if zone
+      (if host
+        (let [h (get-card state host)]
+          (some #(when (= cid (:cid %)) %) (:hosted h)))
+        (some #(when (= cid (:cid %)) %)
+              (get-in @state (cons (to-keyword side) (map to-keyword zone)))))
+      card)))

 (defn update! [state side {:keys [type zone cid host] :as card}]
   (if (= type "Identity")
@@ -1214,6 +1216,7 @@
   ([state side card {:keys [no-cost] :as args}]
      (trigger-event state side :pre-rez card)
      (when (or (#{"Asset" "ICE" "Upgrade"} (:type card)) (:install-rezzed (card-def card)))
+       (trigger-event state side :pre-rez-cost card)
        (let [cdef (card-def card) cost (rez-cost state side card)]
          (when (or no-cost (pay state side card :credit cost (:additional-cost cdef)))
            (card-init state side (assoc card :rezzed true))


Fix so Currents are not resolved twice on play.

--- src/clj/game/core.clj
+++ src/clj/game/core.clj
@@ -80,7 +80,7 @@
          c (if (= (:side c) "Runner") (dissoc c :installed :counter :rec-counter :pump) c)
          c (if keep-counter c (dissoc c :counter :rec-counter :advance-counter))]
      (when-let [leave-effect (:leave-play (card-def card))]
-       (when (or (= (:side card) "Runner") (:rezzed card))
+       (when (or (= (:side card) "Runner") (:rezzed card) (= (first (:zone card)) :current))
          (leave-effect state side card nil)))
      (when-let [prevent (:prevent (card-def card))]
        (doseq [[ptype pvec] prevent]
@@ -971,7 +971,6 @@
          (let [c (move state side (assoc card :seen true) :play-area)]
            (system-msg state side (str "plays " title))
            (trigger-event state side (if (= side :corp) :play-operation :play-event) c)
-           (resolve-ability state side cdef card nil)
            (if (has? c :subtype "Current")
              (do (doseq [s [:corp :runner]]
                    (when-let [current (first (get-in @state [s :current]))]
@@ -979,7 +978,9 @@
                      (trash state side current)))
                  (let [moved-card (move state side (first (get-in @state [side :play-area])) :current)]
                    (card-init state side moved-card)))
-             (move state side (first (get-in @state [side :play-area])) :discard)))))))
+             (do
+               (resolve-ability state side cdef card nil)
+               (move state side (first (get-in @state [side :play-area])) :discard))))))))

 (defn in-play? [state card]
   (let [dest (when (= (:side card) "Runner")


Functions for dynamic ice strengths.

Functions for dynamic ice strengths.

--- src/clj/game/core.clj
+++ src/clj/game/core.clj
@@ -154,6 +154,7 @@
                  (when-let [events (:events (card-def c))]
                    (unregister-events state side c)
                    (register-events state side events c))))))
+         (trigger-event state side :card-moved moved-card)
          moved-card)))))

 (defn draw
@@ -321,10 +322,13 @@
               (resolve-ability state side end-run-effect (:card run-effect) [(first server)]))))
         (swap! state assoc :run nil))))

+(declare update-ice-strength)
+
 (defn add-prop [state side card key n]
   (update! state side (update-in card [key] #(+ (or % 0) n)))
   (when (= key :advance-counter)
-    (trigger-event state side :advance card)))
+    (trigger-event state side :advance card)
+    (when (and (#{"ICE"} (:type card)) (:rezzed card)) (update-ice-strength state side card))))

 (defn set-prop [state side card & args]
   (update! state side (apply assoc (cons card args))))
@@ -392,10 +396,37 @@
        (doseq [dtype prevent]
               (swap! state update-in [:damage :prevent dtype] #(conj % card))))
     (update! state side c)
-    (resolve-ability state side cdef c nil)
     (when-let [events (:events cdef)]
       (register-events state side events c))
+    (resolve-ability state side cdef c nil)
     (get-card state c)))
+
+(defn ice-strength-bonus [state side n]
+  (swap! state update-in [:bonus :ice-strength] (fnil #(+ % n) 0)))
+
+(defn ice-strength [state side {:keys [strength] :as card}]
+  (-> (if-let [strfun (:strength-bonus (card-def card))]
+              (+ strength (strfun state side card nil))
+              strength)
+      (+ (or (get-in @state [:bonus :ice-strength]) 0))))
+
+(defn update-ice-strength [state side ice]
+  (let [ice (get-card state ice) oldstren (or (:current-strength ice) (:strength ice))]
+    (when (:rezzed ice)
+      (swap! state update-in [:bonus] dissoc :ice-strength)
+      (trigger-event state side :pre-ice-strength ice)
+      (update! state side (assoc ice :current-strength (ice-strength state side ice)))
+      ;(when (not= (:current-strength (get-card state ice)) oldstren)
+      (trigger-event state side :ice-strength-changed (get-card state ice) oldstren))))
+
+(defn update-ice-in-server [state side server]
+  (doseq [ice (:ices server)] (update-ice-strength state side ice) ))
+
+(defn update-all-ice [state side]
+  (doseq [central `(:archives :rd :hq)]
+    (update-ice-in-server state side (get-in @state [:corp :servers central])))
+  (doseq [remote (get-in @state [:corp :servers :remote])]
+    (update-ice-in-server state side remote)))

 (defn rez-cost-bonus [state side n]
   (swap! state update-in [:bonus :cost] (fnil #(+ % n) 0)))
@@ -724,22 +755,40 @@
   (let [server (first (get-in @state [:run :server]))]
     (swap! state update-in [:runner :register :unsuccessful-run] #(conj % server))
     (swap! state assoc-in [:run :unsuccessful] true)
+    (update-all-ice state side)
     (trigger-event state side :unsuccessful-run)
     (handle-end-run state side)))

 (defn no-action [state side args]
   (swap! state assoc-in [:run :no-action] true)
-  (system-msg state side "has no further action"))
+  (system-msg state side "has no further action")
+  (when-let [pos (get-in @state [:run :position])]
+    (when-let [ice (when (and pos (> pos 0)) (get-card state (nth (get-in @state [:run :ices]) (dec pos))))]
+      (when (:rezzed ice)
+        (trigger-event state side :encounter-ice ice)
+        (update-ice-strength state side ice)
+        (let [stren (:current-strength (get-card state ice))]
+          (system-msg state :runner (str "encounters " (:title ice) " at strength " stren)))))))

 (defn continue [state side args]
   (when (get-in @state [:run :no-action])
+    (when-let [pos (get-in @state [:run :position])]
+      (when-let [ice (when (and pos (> pos 0)) (get-card state (nth (get-in @state [:run :ices]) (dec pos))))]
+        (trigger-event state side :pass-ice ice)
+        (update-ice-in-server state side (card->server state ice))))
     (swap! state update-in [:run :position] dec)
     (swap! state assoc-in [:run :no-action] false)
     (swap! state assoc-in [:runner :rig :program]
            (for [p (get-in @state [:runner :rig :program])]
              (if (or (not (:current-strength p)) (:all-run p))
                p (assoc p :current-strength nil))))
-    (system-msg state side "continues the run")))
+    (system-msg state side "continues the run")
+    (let [pos (get-in @state [:run :position])]
+      (when (> (count (get-in @state [:run :ices])) 0)
+        (update-ice-strength state side (nth (get-in @state [:run :ices]) pos)))
+      (when (> pos 0)
+        (let [ice (get-card state (nth (get-in @state [:run :ices]) (dec pos)))]
+          (trigger-event state side :approach-ice ice))))))

 (defn play-ability [state side {:keys [card ability targets] :as args}]
   (let [cdef (card-def card)
@@ -861,6 +910,8 @@
          (when (or no-cost (pay state side card :credit cost (:additional-cost cdef)))
            (card-init state side (assoc card :rezzed true))
            (system-msg state side (str "rez " (:title card) (when no-cost " at no cost")))
+           (resolve-ability state side cdef card nil)
+           (when (#{"ICE"} (:type card)) (update-ice-strength state side card))
            (trigger-event state side :rez card))))))

 (defn corp-install
@@ -904,6 +955,8 @@
 (defn derez [state side card]
   (system-msg state side (str "derez " (:title card)))
   (update! state :corp (desactivate state :corp card true))
+  (when-let [derez-effect (:derez-effect (card-def card))]
+    (resolve-ability state side derez-effect (get-card state card) nil))
   (trigger-event state side :derez card))

 (defn advance [state side {:keys [card]}]


Directory cleaner did not fully clean

Directory cleaner did not fully clean

--- src/clj/runbld/io.clj
+++ src/clj/runbld/io.clj
@@ -47,19 +47,26 @@

 (defn rmdir-r [dir]
   (let [f (fn [[x & xs]]
-            (if (or (.isFile x)
+            (when x
+              (cond
+                ;; Leaf (file or empty directory)
+                (or (.isFile x)
                     (and (.isDirectory x)
                          (zero? (count (.listFiles x)))))
-              (do
-                (when (windows?)
-                  (System/gc)
-                  (.setWritable x true))
-                (again/with-retries [100 500 500]
-                  (println "deleting" x)
-                  (jio/delete-file x)))
-              (recur (concat (if (.isDirectory x)
-                               (.listFiles x))
-                             xs))))]
+                (do
+                  (when (windows?)
+                    (System/gc)
+                    (.setWritable x true))
+                  (again/with-retries [100 500 500]
+                    (println "deleting" x)
+                    (jio/delete-file x))
+                  (recur xs))
+
+                ;; Node (non-empty directory)
+                (and (.isDirectory x)
+                     (pos? (count (.listFiles x))))
+                (recur
+                 (concat (.listFiles x) [x] xs)))))]
     (f [(jio/file dir)])))

 (defn mkdir-p [dir]


fixed issues with om tests (removed extra spans)

--- test/kioo/om_test.cljs
+++ test/kioo/om_test.cljs
@@ -18,27 +18,27 @@
 (deftest render-test
   (testing "basic render test"
     (let [comp (component "simple-div.html" {}) ]
-      (is (= "
test
"
+      (is (= "
test
"
              (render-dom comp)))))
   (testing "content replace"
     (let [comp (component "simple-div.html"
                           {[:div] (content "success")})]
-      (is (= "
success
"
+      (is (= "
success
"
              (render-dom comp)))))
   (testing "first-of-type naked symbol"
     (let [comp (component "list.html" [:ul [:li first-of-type]] {})]
-      (is (= "
1
" (render-dom comp)))))
+      (is (= "
1
" (render-dom comp)))))
   (testing "attr= content replace"
     (let [comp (component "simple-attr-div.html"
                           {[(attr= :data-id "tmp")]
                            (content "success")})]
-      (is (= "
success
"
+      (is (= "
success
"
              (render-dom comp)))))
   (testing "attr? content replace"
     (let [comp (component "simple-attr-div.html"
                           {[(attr? :data-id)]
                            (content "success")})]
-      (is (= "
success
"
+      (is (= "
success
"
              (render-dom comp)))))
   (testing "append test"
     (let [comp (component "simple-div.html"
@@ -56,64 +56,64 @@
   (testing "set-attr test"
     (let [comp (component "simple-div.html"
                           {[:div] (set-attr :id "success")})]
-      (is (= "
test
"
+      (is (= "
test
"
              (render-dom comp)))))
   (testing "remove-attr test"
     (let [comp (component "simple-div.html"
                           {[:div] (remove-attr :id)})]
-      (is (= "
test
"
+      (is (= "
test
"
              (render-dom comp)))))
   (testing "before test"
     (let [comp (component "simple-div.html"
                           {[:div] (before "success")})]
-      (is (= "success
test
"
+      (is (= "success
test
"
              (render-dom comp)))))
   (testing "after test"
     (let [comp (component "simple-div.html"
                           {[:div] (after "success")})]
-      (is (= "
test
success"
+      (is (= "
test
success"
              (render-dom comp)))))
   (testing "add-class test"
     (let [comp (component "class-span.html" [:span]
                           {[:#s] (add-class "suc")})]
-      (is (= "testing"
+      (is (= "testing"
              (render-dom comp)))))
   (testing "remove-class test"
     (let [comp (component "class-span.html" [:span]
                           {[:#s] (remove-class "cl")})]
-      (is (= "testing"
+      (is (= "testing"
              (render-dom comp)))))
   (testing "set-class test"
     (let [comp (component "class-span.html" [:span]
                           {[:#s] (set-class "cl")})]
-      (is (= "testing"
+      (is (= "testing"
              (render-dom comp)))))
   (testing "set-style test"
     (let [comp (component "style-span.html" [:span]
                           {[:#s] (set-style :display "none")})]
-      (is (= "testing"
+      (is (= "testing"
              (render-dom comp)))))
   (testing "remove-style test"
     (let [comp (component "style-span.html" [:span]
                           {[:#s] (remove-style :color)})]
-      (is (= "testing"
+      (is (= "testing"
              (render-dom comp)))))
   (testing "do-> test"
     (let [comp (component "style-span.html" [:span]
                           {[:#s] (do->
                                   (remove-attr :id)
                                   (remove-style :color))})]
-      (is (= "testing"
+      (is (= "testing"
              (render-dom comp)))))
   (testing "wrap test"
     (let [comp (component "wrap-test.html" [:span]
                           {[:#s] (wrap :div {:id "test"})})]
-      (is (= "
testing
"
+      (is (= "
testing
"
              (render-dom comp)))))
   (testing "unwrap test"
     (let [comp (component "wrap-test.html" [:div]
                           {[:div] unwrap})]
-      (is (= "testing"
+      (is (= "testing"
              (render-dom comp)))))
   (testing "html test"
     (let [comp (component "simple-div.html"
@@ -147,31 +147,31 @@
 (deftest snippet_template_test
   (testing "basic setup for snippet"
     (let [comp (snippet "wrap-test.html" [:span] [] {})]
-      (is (= "testing"
+      (is (= "testing"
              (render-dom (comp))))))
   (testing "basic setup for template"
     (let [comp (template "simple-div.html" [] {})]
-      (is (= "
test
"
+      (is (= "
test
"
              (render-dom (comp))))))
   (testing "simple tranform for snippet"
     (let [comp (snippet "wrap-test.html" [:span] [val]
                         {[:span] (content val)})]
-      (is (= "test"
+      (is (= "test"
              (render-dom (comp "test"))))))
   (testing "simple transform for template"
     (let [comp (template "simple-div.html" [val]
                          {[:div] (content val)})]
-      (is (= "
success
"
+      (is (= "
success
"
              (render-dom (comp "success"))))))
   (testing "basic setup for defsnippet"
-    (is (= "testing"
+    (is (= "testing"
            (render-dom (snip1)))))
   (testing "basic setup for deftemplate"
-    (is (= "
test
"
+    (is (= "
test
"
            (render-dom (tmp1)))))
   (testing "simple transform for defsnippet"
-    (is (= "test"
+    (is (= "test"
            (render-dom (snip2 "test")))))
   (testing "simple transform for deftemplate"
-    (is (= "
success
"
+    (is (= "
success
"
            (render-dom (tmp2 "success"))))))


added future fact - faking vars directly (issue #69)

--- test/midje/t_sweet.clj
+++ test/midje/t_sweet.clj
@@ -223,6 +223,14 @@
   (do (called 1) (called 1)) => 1
   (provided
     (called 1) => 1))
+
+(defn f [x] (inc x))
+(defn g [x] (* x (f x)))
+
+(future-fact "can fake vars directly"
+  (#'g 2) => 6
+  (provided
+    (#'f 2) => 2))

 ;; Possibly the most common case
 (after-silently


remove duplicate test

remove duplicate test

--- test/tracks/core_test.clj
+++ test/tracks/core_test.clj
@@ -32,12 +32,6 @@
     (is (= 2 (t/let [{:a a} {:a 1}
                      b      (+ a a)]
                 b)))))
-
-(deftest track-let
-  (testing "multiple bindings"
-    (is (= 2 (t/let [{:a a} {:a 1}
-                     b      (+ a a)]
-               b)))))

 (deftest track-works
   (testing "can move keys"


Console reporter does not print/indent empty doc strings

--- src/main/clojure/lazytest/report/console.clj
+++ src/main/clojure/lazytest/report/console.clj
@@ -21,10 +21,12 @@
 (extend-protocol ConsoleTestReport
   lazytest.result.TestResultGroup
   (p [r l]
-     (indent l)
-     (println (colorize (docs r) (if (success? r) :green :red)))
-     (doseq [c (:children r)]
-       (p c (inc l))))
+     (when (seq (docs r))
+       (indent l)
+       (println (colorize (docs r) (if (success? r) :green :red))))
+     (let [sub-indent (if (seq (docs r)) (inc l) l)]
+       (doseq [c (:children r)]
+	 (p c sub-indent))))

   lazytest.result.Pass
   (p [r l]


Remove direct servlet example.

Remove direct servlet example.

--- src/demo/web.clj
+++ src/demo/web.clj
@@ -19,14 +19,6 @@
     (-> (ring-util/response (str "You accessed this page " count " times\n"))
         (assoc :session session))))

-(def servlet
-  (proxy [HttpServlet] []
-    (service [^HttpServletRequest request ^HttpServletResponse response]
-      (let [session (.getSession request)
-            count (or (.getAttribute session "count") 0)]
-        (-> response .getWriter (.write (str "You've visited " count " times\n")))
-        (.setAttribute session "count" (inc count))))))
-
 (defn -main
   [& {:as args}]

@@ -39,5 +31,4 @@
     (javax/create-servlet #'counter)
     :path "/counter")

-  (web/run servlet :path "/session")
   )


Add lein exec plugin.

Add lein exec plugin.

--- .lein/profiles.clj
+++ .lein/profiles.clj
@@ -1 +1 @@
-{:user {:plugins []}}
+{:user {:plugins [[lein-exec "0.3.0"]]}}


Use em/text and em/token

Use em/text and em/token

--- src/ctia/entity/investigation.clj
+++ src/ctia/entity/investigation.clj
@@ -21,18 +21,10 @@
    [ctia.schemas.sorting :as sorting]))

 (def snapshot-action-fields-mapping
-  {:object_ids {:type "text"
-                :analyzer "text_analyzer"
-                :search_quote_analyzer "text_analyzer"
-                :search_analyzer "search_analyzer"
-                :include_in_all false}
+  {:object_ids em/token
    :targets {:type "nested"
              :include_in_all false}
-   :investigated_observables {:type "text"
-                              :analyzer "text_analyzer"
-                              :search_quote_analyzer "text_analyzer"
-                              :search_analyzer "search_analyzer"
-                              :include_in_all false}})
+   :investigated_observables em/text})

 (def investigation-mapping
   {"investigation"


Also complete static fields of fully qualified classes

--HG--
branch : bleeding-edge

--- src/de/kotka/vimclojure/nails.clj
+++ src/de/kotka/vimclojure/nails.clj
@@ -200,25 +200,31 @@
     (catch Exception e
       (println false))))

-(defn- decide-completion
-  [prefix base]
-  (if (pos? (count prefix))
-    (cond
-      (Character/isUpperCase (char (first prefix))) [:static-field]
-      :else [:local-var])
-    (cond
-      (Character/isUpperCase (char (first base))) [:import]
-      (< -1 (.indexOf base (int \.)))             [:namespace]
-      :else [:full-var :alias :namespace])))
+(defn- decide-completion-in
+  [nspace prefix base]
+  (let [prefixs (symbol prefix)]
+    (if (pos? (count prefix))
+      (cond
+        (or (Character/isUpperCase (char (first prefix)))
+            (try
+              (ns-resolve nspace prefixs)
+              true
+              (catch ClassNotFoundException _ false))) [:static-field]
+        (or (contains? (all-ns) prefixs)
+            (contains? (ns-aliases nspace) prefixs))   [:local-var])
+      (cond
+        (Character/isUpperCase (char (first base))) [:import]
+        (< -1 (.indexOf base (int \.)))             [:namespace]
+        :else [:full-var :alias :namespace]))))

 (defnail Complete
   "Usage: ng de.kotka.vimclojure.nails.Complete"
   [[nspace n "Start completion in this namespace." "user"]
    [prefix p "Prefix used for the match, ie. the part before /." ""]
    [base   b "Base pattern to be matched."]]
-  (let [_ (resolve-and-load-namespace nspace)]
+  (let [the-space (resolve-and-load-namespace nspace)]
     (if-not (and (= base "") (= prefix ""))
-      (let [to-complete (decide-completion prefix base)
+      (let [to-complete (decide-completion-in the-space prefix base)
             completions (mapcat #(complete % nspace prefix base) to-complete)
             completions (map #(apply make-completion-item %) completions)]
         (println (clj->vim completions)))


valid marble moves to multi method

valid marble moves to multi method

--- src/nonaga/draw/draw_valid_marble_moves.cljs
+++ src/nonaga/draw/draw_valid_marble_moves.cljs
@@ -1,10 +1,10 @@
 (ns nonaga.draw.draw-valid-marble-moves
   (:require [nonaga.rules.ball :as b]
             [nonaga.core :as n])
-  (:use [nonaga.draw.util :only [hex->svg marble update-state]]))
+  (:use [nonaga.draw.util :only [hex->svg marble update-state event-type]]))

 (def light-colors
-  {:red :pink
+  {:red  :pink
    :blue :lightblue})

 (defn move-marble [component color from to]
@@ -12,12 +12,15 @@
                 #(-> % (n/move-ball color from to)
                      (assoc :event [:marble-moved color]))))

-(defn draw-valid-marble-moves [component state]
-  (let [[type & event-data] (:event state)]
-    (when (= :marble-selected type)
-      (let [[color selected] event-data]
-        (map (fn [hex]
-               (marble (light-colors color)
-                       (move-marble component color selected hex)
-                       (hex->svg hex)))
-              (b/valid-destinations state selected))))))
+(defmulti draw-valid-marble-moves #(event-type %2))
+
+(defmethod draw-valid-marble-moves :default [_ _])
+
+(defmethod draw-valid-marble-moves :marble-selected
+  [component {[t color selected] :event :as state}]
+  (map (fn [hex]
+         (marble (light-colors color)
+                 (move-marble component color selected hex)
+                 (hex->svg hex)))
+       (b/valid-destinations state selected)))
+


Use messaging short-id invariant.

Use messaging short-id invariant.

--- src/onyx/scheduling/common_job_scheduler.clj
+++ src/onyx/scheduling/common_job_scheduler.clj
@@ -523,7 +523,10 @@
                :dst-task-id task
                :msg-slot-id slot}))))

-(defn add-messaging-short-ids [replica]
+(defn add-messaging-short-ids
+  "Converts long form messaging identifies into short int identifiers, for
+   quick comparison and reduced message size."
+  [replica]
   (assoc replica
          :message-short-ids
          (->> replica
@@ -545,7 +548,8 @@
           (invariants/all-peers-are-reverse-group-indexed %)
           (invariants/all-jobs-have-coordinator %)
           (invariants/no-extra-coordinators %)
-          (invariants/all-coordinators-exist %)]}
+          (invariants/all-coordinators-exist %)
+          (invariants/short-identifiers-correct %)]}
   (-> new
       (reallocate-peers)
       (add-allocation-versions old)


Include selection controls

Include selection controls

--- frontend/src/cruncher/views.cljs
+++ frontend/src/cruncher/views.cljs
@@ -5,35 +5,24 @@
             [cruncher.communication.auth :as auth]
             [cruncher.communication.main :as com]
             [cruncher.communication.progress :as progress]
+            [cruncher.selections :as selections]
             [cruncher.shredder.main :as shredder]
             [cruncher.utils.extensions]
             [cruncher.utils.lib :as lib]
             [cruncher.utils.views :as vlib]))

-;;;; Selections
-(defn select-all-but-favorite
-  []
-  (let [rows (gdom/getElementsByClass "poketable-row")]
-    (doall (map (fn [row]
-                  (let [id (.getAttribute row "data-id")
-                        favorite (.getAttribute row "data-favorite")
-                        checkbox (gdom/getElement (str "poketable-checkbox-" id))]
-                    (when-not (= "true" favorite)
-                      (set! (.. checkbox -checked) true)))) rows))))
-
 ;;;; Controls
 (defui Controls
   Object
   (render [this]
     (dom/div nil
              (dom/span #js {:className "pull-right"} (vlib/loader (om/props this)))
+             (dom/p #js {:className "lead"} "Controls")
              (vlib/button-primary #(com/route :get-all-pokemon) "Get all Pokemon")
-             " "
              (vlib/button-primary #(shredder/power-on this) (dom/span nil (vlib/fa-icon "fa-eraser") " Crunch selected Pokemon"))
-             " "
-             (vlib/button-primary select-all-but-favorite "Select all but favorite")
-             (dom/br nil)
-             (dom/br nil)
+             (dom/br nil) (dom/br nil)
+             (selections/controls)
+             (dom/br nil) (dom/br nil)
              (dom/div nil (progress/progress-bar (om/props this))))))
 (def controls (om/factory Controls))


(PDB-5161) engine: use parse-field instead of string operations

Replace various remaining uses of string operations like splitting a
field on #"\." with parse-field.

--- src/puppetlabs/puppetdb/query_eng/engine.clj
+++ src/puppetlabs/puppetdb/query_eng/engine.clj
@@ -2062,7 +2062,9 @@
                      "Argument \"{0}\" is incompatible with numeric field \"{1}\"."
                      value (name field))))))

-              [[(:or ">" ">=" "<" "<=")  (field :guard #(not (str/includes? %  "."))) _]]
+              [[(:or ">" ">=" "<" "<=")
+                (field :guard #(= (count (parse/parse-field %)) 1))
+                _]]
               (let [col-type (get-in query-context [:projections field :type])]
                 (when-not (or (vec? field)
                               (contains? #{:numeric :timestamp :jsonb-scalar}
@@ -2366,8 +2368,9 @@
                                         :value value}))

             [["=" column-name value]]
-            (let [colname (first (str/split column-name #"\."))
-                  cinfo (get-in query-rec [:projections colname])]
+            ;; FIXME: pass parsed representation down
+            (let [[top & path] (parse/parse-field column-name)
+                  cinfo (get-in query-rec [:projections (:name top)])]
               (case (:type cinfo)
                :timestamp
                (map->BinaryExpression {:operator :=
@@ -2384,7 +2387,7 @@
                                        :value (facts/factpath-to-string value)})

                :queryable-json
-               (if (string/includes? column-name "[")
+               (if (some #(= ::parse/indexed-field-part (:kind %)) path)
                  (map->JsonbPathBinaryExpression {:field column-name
                                                   :column-data cinfo
                                                   :value value
@@ -2442,8 +2445,9 @@
                                                                    (map str value))})))

             [[(op :guard #{">" "<" ">=" "<="}) column-name value]]
-            (let [colname (first (str/split column-name #"\."))
-                  {:keys [type] :as cinfo} (get-in query-rec [:projections colname])]
+            ;; FIXME: pass parsed representation down
+            (let [[top & path] (parse/parse-field column-name)
+                  {:keys [type] :as cinfo} (get-in query-rec [:projections (:name top)])]
               (cond
                 (= :timestamp type)
                 (map->BinaryExpression {:operator (keyword op)
@@ -2498,8 +2502,9 @@
                 (map->NullExpression {:column cinfo :null? value})))

             [["~" column-name value]]
-            (let [colname (first (str/split column-name #"\."))
-                  cinfo (get-in query-rec [:projections colname])]
+            ;; FIXME: pass parsed representation down
+            (let [[top] (parse/parse-field column-name)
+                  cinfo (get-in query-rec [:projections (:name top)])]
               (case (:type cinfo)
                 :array
                 (map->ArrayRegexExpression {:column cinfo :value value})


conflicts/duplicates removed completely - tests pass

--- src/io/aviso/rook.clj
+++ src/io/aviso/rook.clj
@@ -236,14 +236,6 @@
                    rook-handler
                    (apply compojure/routes (concat handlers [rook-handler])))
          handler' (namespace-middleware handler namespace-name)]
-     (compojure/context path [] handler'))))
-
-  ([namespace-name]
-   (namespace-middleware rook-handler namespace-name))
-  ([path namespace-name & handlers]
-   (let [handler (if (empty? handlers)
-                   rook-handler
-                   (apply compojure/routes (concat handlers [rook-handler])))
-         handler' (namespace-middleware handler namespace-name)]
-     (compojure/context path [] handler'))))
-
+     (compojure/context path [] handler'))) )
+
+


Simplify show method

Simplify show method

--- template/src/leiningen/new/play_clj/core.clj
+++ template/src/leiningen/new/play_clj/core.clj
@@ -6,7 +6,7 @@
   :on-show
   (fn [screen entities]
     (update! screen :renderer (stage))
-    (conj entities (label "Hello world!" (color :white))))
+    (label "Hello world!" (color :white)))
   :on-render
   (fn [screen entities]
     (clear!)


Make cmd line command handling more robust.

--- src/lexemic/core.cljs
+++ src/lexemic/core.cljs
@@ -2,23 +2,32 @@
   (:require [cljs.nodejs :as node]
             [lexemic.sentiment.simple :as sentiment]))

+(def ^:private version
+  (.-version (node/require "./package.json")))
 (def ^:private fs
   (node/require "fs"))

+(def ^:private spacer "")
+(def ^:private version (str "Lexemic v" version))
 (def ^:private usage-banner "Usage: lexemic [command] [implementation] [target...]")
 (def ^:private supported-commands #{"help" "sentiment"})

-(defn- help []
-  (str usage-banner))
+(defn- show-help []
+  (do
+    (println version)
+    (println spacer)
+    (println usage-banner)))

 (defn- run [cmd impl text]
   (condp = cmd
-    "sentiment" (sentiment/analyse text)))
+    "sentiment" (prn (sentiment/analyse text))
+    (show-help)))

 (defn -main [& args]
   (let [command (first args)
-        impl (when (.match (second args) #"^-{1,2}")
-               (second args))
+        impl (let [impl* (second args)]
+               (when (and impl* (.match impl* #"^-{1,2}"))
+                 impl*))
         targets (if impl
                   (drop 2 args)
                   (drop 1 args))
@@ -31,7 +40,7 @@
         contents (map get-string targets)
         input (print-str contents)]
     (if-let [cmd (supported-commands command)]
-      (println (run cmd impl input))
-      (println (help)))))
+      (run cmd impl input)
+      (show-help))))

 (set! *main-cli-fn* -main)


Rename `content-pre-wrap` to `content-task` in `pandoc`

--- src/io/perun.clj
+++ src/io/perun.clj
@@ -426,7 +426,7 @@
    m meta       META       edn   "metadata to set on each entry"
    o cmd-opts   CMDOPTS    [str] "command line options to send to pandoc"]
   (let [options (merge +pandoc-defaults+ *opts*)]
-    (content-pre-wrap
+    (content-task
      {:render-form-fn (fn [data] `(io.perun.pandoc/process-pandoc ~data ~cmd-opts))
       :paths-fn #(content-paths % options)
       :passthru-fn content-passthru


using sablono

using sablono

--- src/my_todo/core.cljs
+++ src/my_todo/core.cljs
@@ -1,6 +1,7 @@
 (ns ^:figwheel-always my-todo.core
     (:require-macros [cljs.core.async.macros :refer [go]])
     (:require [om.core :as om :include-macros true]
+              [sablono.core :as html :refer-macros [html]]
               [om.dom :as dom :include-macros true]
               [cljs.core.async :refer [put! chan <!]]
               [ajax.core :refer [GET POST]]))
@@ -13,7 +14,7 @@

 (defonce app-state
   (atom
-    {:comments [] }))
+    {:comments [{:author "g" :text "fasdf"}]}))

 ;;ajax

@@ -32,6 +33,7 @@
      :keywords? true
      :handler (partial get-comments #(put! comm [:init %] ))
      :error-handler error-handler}))
+

 (defn save-commemnt [new-comment]
   (POST "http://localhost:3000/comments"
@@ -77,24 +79,24 @@

     om/IRenderState
     (render-state [_ {:keys [comm] :as state}]
-      (dom/form #js {:className "commentForm"
-                     :onSubmit #(add-comment % owner state)}
-        (dom/input #js {:type "text"
-                        :placeholder "Your name"
-                        :value (:author state)
-                        :onChange #(handle-change % owner "author")})
-        (dom/input #js {:type "text"
-                        :placeholder "Say something"
-                        :value (:text state)
-                        :onChange #(handle-change % owner "text")})
-        (dom/input #js {:type "submit" :value "Post"})))))
+      (html [:form {:class "commentForm"
+                    :on-submit #(add-comment % owner state)}
+        [:input {:type "text"
+                :placeholder "Your name"
+                :value (:author state)
+                :on-change #(handle-change % owner "author")}]
+        [:input  {:type "text"
+                  :placeholder "Say something"
+                  :value (:text state)
+                  :on-change #(handle-change % owner "text")}]
+        [:input {:type "submit" :value "Post"}]]))))

 ;;main component

 (defn handle-comm-event [t app val]
   (case t
     :add (om/transact! app :comments #(conj % val))
-    :init (om/update! app {:comments val})
+    :init (om/update! app [:comments] val)
     nil))

 (defn render-comment-list [{:keys [comments]}]
@@ -109,17 +111,18 @@
       (let [comm (chan)]
         (om/set-state! owner :comm comm)
           (go
-           (load-data comm)
-           (while true
-            (let [ [t value] (<! comm)]
-              (handle-comm-event t app value))))))
+            (load-data comm)
+            (while true
+              (let [ [t value] (<! comm)]
+                (handle-comm-event t app value))))))

     om/IRenderState
     (render-state [_ {:keys [comm]}]
-      (dom/div #js {:className "commentBox"}
-        (dom/h1 nil "Comments")
-        (render-comment-list app)
-        (om/build comment-form nil {:init-state {:comm comm}})))))
+      (html
+        [:div {:class "commentBox"}
+          [:h1 "Comments"]
+          (render-comment-list app)
+          (om/build comment-form nil {:init-state {:comm comm}})]))))

 (om/root
   comment-box


bump deps

bump deps

--- build.boot
+++ build.boot
@@ -4,29 +4,29 @@
  :source-paths    #{"src/main"}
  :resource-paths  #{"resources"}
  :dependencies '[[org.clojure/clojure         "1.9.0-alpha13"  :scope "provided"]
-                 [org.clojure/clojurescript   "1.9.229"        :scope "provided"]
-                 [org.omcljs/om               "1.0.0-alpha46"  :scope "provided"
+                 [org.clojure/clojurescript   "1.9.293"        :scope "provided"]
+                 [org.omcljs/om               "1.0.0-alpha47"  :scope "provided"
                   :exclusions [cljsjs/react]]

                  [cljsjs/react-with-addons    "15.3.1-0"       :scope "test"]
                  [cljsjs/react-dom            "15.3.1-0"       :scope "test"
                   :exclusions [cljsjs/react]]
                  [com.cognitect/transit-clj   "0.8.290"        :scope "test"]
-                 [org.clojure/core.async      "0.2.391"        :scope "test"]
+                 [org.clojure/core.async      "0.2.395"        :scope "test"]
                  [devcards                    "0.2.2"          :scope "test"
                   :exclusions [cljsjs/react cljsjs/react-dom]]
                  [com.cemerick/piggieback     "0.2.1"          :scope "test"]
                  [pandeiro/boot-http          "0.7.3"          :scope "test"]
-                 [adzerk/boot-cljs            "1.7.228-1"      :scope "test"]
+                 [adzerk/boot-cljs            "1.7.228-2"      :scope "test"]
                  [adzerk/boot-cljs-repl       "0.3.3"          :scope "test"]
                  [adzerk/boot-test            "1.1.2"          :scope "test"]
                  [crisptrutski/boot-cljs-test "0.2.2-SNAPSHOT" :scope "test"]
-                 [adzerk/boot-reload          "0.4.12"         :scope "test"]
+                 [adzerk/boot-reload          "0.4.13"         :scope "test"]
                  [adzerk/bootlaces            "0.1.13"         :scope "test"]
                  [org.clojure/tools.nrepl     "0.2.12"         :scope "test"]
                  [org.clojure/tools.namespace "0.3.0-alpha3"   :scope "test"]
                  [weasel                      "0.7.0"          :scope "test"]
-                 [boot-codox                  "0.10.0"         :scope "test"]])
+                 [boot-codox                  "0.10.1"         :scope "test"]])

 (require
  '[adzerk.boot-cljs      :refer [cljs]]


Fix deployment

Fix deployment

--- build.boot
+++ build.boot
@@ -7,8 +7,8 @@
 (defn get-version []
   (read-string (slurp "release.edn")))

-(defn format-version [segments]
-  (clojure.string/join "." segments))
+(defn format-version [{:keys [version]}]
+  (clojure.string/join "." version))

 (task-options! pom
                {:project 'boot-fmt/boot-fmt,


Cider tasks does not work in Jenkins.

Cider tasks does not work in Jenkins.

--- build.boot
+++ build.boot
@@ -186,5 +186,6 @@
   "Cider boot params task"
   []
   (comp
-    (cider)
+    ; What does this task do and it is really required? FIXME/TODO
+    ;(cider)
     (cljs-dev)))


update build script

update build script

--- build.boot
+++ build.boot
@@ -9,7 +9,7 @@

 (require '[boot.git :as git])

-(def +VERSION+ "0.0-2371-0-SNAPSHOT")
+(def +VERSION+ "0.0-2371-0")

 (task-options!
   pom [:project     'tailrecursion/boot-cljs


Prepare extension of test-cli-stderr.

Prepare extension of test-cli-stderr.

--- src/cli4clj/cli_tests.clj
+++ src/cli4clj/cli_tests.clj
@@ -51,11 +51,6 @@
         (sl s)
         s))))

-(defn test-cli-stderr
-  "Takes a function to be tested and a vector of string input commands and returns the string that was printed to stderr as a result of executing the supplied commands in the cli provided by the tested-fn."
-  [tested-fn in-cmds]
-  (.trim (utils/with-err-str (with-in-str (cmd-vector-to-test-input-string in-cmds) (exec-tested-fn tested-fn)))))
-
 (defn test-cli-stderr-custom
   "Takes a function to be tested and a vector of string input commands and returns the string that was printed to stdout as a result of executing the supplied commands in the cli provided by the tested-fn.
    In addition the function f will be called for each element that is written to stderr."
@@ -64,6 +59,18 @@
            f
            (with-in-str (cmd-vector-to-test-input-string in-cmds)
              (exec-tested-fn tested-fn)))))
+
+(defn test-cli-stderr
+  "Takes a function to be tested and a vector of string input commands and returns the string that was printed to stderr as a result of executing the supplied commands in the cli provided by the tested-fn."
+  ([tested-fn in-cmds]
+    (.trim (utils/with-err-str (with-in-str (cmd-vector-to-test-input-string in-cmds) (exec-tested-fn tested-fn)))))
+  ([tested-fn in-cmds sl]
+    (test-cli-stderr-custom
+      tested-fn
+      in-cmds
+      (fn [s]
+        (sl s)
+        s))))

 (defn expected-string
   "Takes a vector of strings that are intended to represent individual line of expected command line output and converts them into a string that can be compared against the output of the test-cli-stdout and test-cli-stderr functions.


tweak reader/read call based on feedback from Nicola Mometto & Alex Miller

--- src/clj/cljs/analyzer.clj
+++ src/clj/cljs/analyzer.clj
@@ -1964,22 +1964,24 @@
   ([^Reader rdr] (forms-seq* rdr nil))
   ([^Reader rdr filename]
    {:pre [(instance? Reader rdr)]}
-   (let [opts (when (and filename (= (util/ext filename) "cljc"))
-                {:read-cond :allow :features #{:cljs}})
+   (let [eof-sentinel (Object.)
+         opts (merge
+                {:eof eof-sentinel}
+                (if (and filename (= (util/ext filename) "cljc"))
+                  {:read-cond :allow :features #{:cljs}}))
          pbr (readers/indexing-push-back-reader
                (PushbackReader. rdr) 1 filename)
          data-readers tags/*cljs-data-readers*
          forms-seq_
          (fn forms-seq_ []
            (lazy-seq
-             (let [eof-sentinel (Object.)
-                   form (binding [*ns* (create-ns *cljs-ns*)
+             (let [form (binding [*ns* (create-ns *cljs-ns*)
                                   reader/*data-readers* data-readers
                                   reader/*alias-map*
                                   (apply merge
                                     ((juxt :requires :require-macros)
                                       (get-namespace *cljs-ns*)))]
-                          (reader/read pbr nil eof-sentinel opts nil))]
+                          (reader/read opts pbr))]
                (if (identical? form eof-sentinel)
                  (.close rdr)
                  (cons form (forms-seq_))))))]


Actually seed orderings with the last layer of the previous ordering

--- src/cljs/fatlip/core.cljs
+++ src/cljs/fatlip/core.cljs
@@ -547,30 +547,27 @@

 (defn SparseGraph->OrderedGraph
   "Performs one layer-by-layer sweep of the graph using ESK's algorithm"
-  [sparse-graph]
-  (let [first-sparse-layer (-> sparse-graph :layers first)]
-    (loop [prev-layer (map->OrderedLayer (-> first-sparse-layer
-                                             (dissoc :nodes)
-                                             (assoc :items (:nodes first-sparse-layer))))
-           ordered-graph (map->OrderedGraph {:layers [prev-layer]
-                                             :succs (:succs sparse-graph)
-                                             :preds (:preds sparse-graph)
-                                             :crossings 0
-                                             :marked #{}})
-           layers (-> sparse-graph :layers rest)]
-      (if (empty? layers)
-        ordered-graph
-        (let [[o-layer crossings marked] (order-sparse-layer (first layers)
-                                                             prev-layer
-                                                             (:ps sparse-graph)
-                                                             (:qs sparse-graph)
-                                                             (:succs sparse-graph)
-                                                             (:preds sparse-graph))
-              g (-> ordered-graph
-                    (update-in [:layers] conj o-layer)
-                    (update-in [:crossings] + crossings)
-                    (update-in [:marked] set/union marked))]
-          (recur o-layer g (rest layers)))))))
+  [sparse-graph first-layer]
+  (loop [ordered-graph (map->OrderedGraph {:layers [first-layer]
+                                           :succs (:succs sparse-graph)
+                                           :preds (:preds sparse-graph)
+                                           :crossings 0
+                                           :marked #{}})
+         prev-layer first-layer
+         layers (-> sparse-graph :layers rest)]
+    (if (empty? layers)
+      ordered-graph
+      (let [[o-layer crossings marked] (order-sparse-layer (first layers)
+                                                           prev-layer
+                                                           (:ps sparse-graph)
+                                                           (:qs sparse-graph)
+                                                           (:succs sparse-graph)
+                                                           (:preds sparse-graph))
+            g (-> ordered-graph
+                  (update-in [:layers] conj o-layer)
+                  (update-in [:crossings] + crossings)
+                  (update-in [:marked] set/union marked))]
+        (recur g o-layer (rest layers))))))

 (defn orderings
@@ -582,17 +579,29 @@
   - Removed the concept of alternating layers, which don't help much, and hurt a bit
   - Added weights to nodes and edges"
   [sparse-graph]
-  ;; seed the first layer with initial ordered layer
-  (loop [orderings []]
-    (let [c (count orderings)]
-      (if (= c 20)
-        orderings
-        (let [reverse? (odd? c)
-              ordered-graph (-> (if reverse?
-                                  (reverse-graph sparse-graph)
-                                  sparse-graph)
-                                SparseGraph->OrderedGraph)]
-          (recur (conj orderings (if reverse? (reverse-graph ordered-graph) ordered-graph))))))))
+  (let [first-sparse-layer (-> sparse-graph :layers first)]
+    (loop [orderings []
+           ;; seed the first layer with initial ordered layer
+           first-layer (map->OrderedLayer
+                        (-> first-sparse-layer
+                            (dissoc :nodes)
+                            (assoc :items (:nodes first-sparse-layer))))
+           first-layers #{first-layer}]
+      (let [c (count orderings)]
+        (if (= c 20)
+          orderings
+          (let [reverse? (odd? c)
+                ordered-graph (-> (if reverse?
+                                    (reverse-graph sparse-graph)
+                                    sparse-graph)
+                                  (SparseGraph->OrderedGraph first-layer))
+                ords (conj orderings (if reverse?
+                                       (reverse-graph ordered-graph)
+                                       ordered-graph))
+                layers (:layers ordered-graph)
+                last-layer (layers (dec (count layers)))]
+            ;; The last layer of the current ordering is the first layer of the next
+            (recur ords last-layer (conj first-layers last-layer))))))))

 (defn neighborify


Moar.

Moar.

--- src/clojurecraft/core.clj
+++ src/clojurecraft/core.clj
@@ -33,6 +33,8 @@
   0x18 :mobspawn
   0x19 :entitypainting
   0x1B :stanceupdate
+  0x1C :entityvelocity
+  0x1D :entitydestroy
 })
 (def packet-ids (apply assoc {} (mapcat reverse packet-types)))

@@ -232,6 +234,14 @@
   (-write-bool conn unknown4)
   (-write-float conn unknown5)
   (-write-float conn unknown6))
+
+(defn write-packet-entityvelocity [conn {eid :eid velocityx :velocityx velocityy :velocityy velocityz :velocityz}]
+  (-write-byte conn (:entityvelocity packet-ids))
+
+  (-write-int conn eid)
+  (-write-short conn velocityx)
+  (-write-short conn velocityy)
+  (-write-short conn velocityz))

 ; Writing Wrappers -----------------------------------------------------------------
@@ -258,6 +268,7 @@
     (= packet-type :pickupspawn)          (write-packet-pickupspawn conn payload)
     (= packet-type :entitypainting)       (write-packet-entitypainting conn payload)
     (= packet-type :stanceupdate)         (write-packet-stanceupdate conn payload)
+    (= packet-type :entityvelocity)       (write-packet-entityvelocity conn payload)
     )
   (flushc conn))

@@ -473,6 +484,17 @@
     (assoc :unknown4 (-read-bool conn))
     (assoc :unknown5 (-read-float conn))
     (assoc :unknown6 (-read-float conn))))
+
+(defn read-packet-entityvelocity [conn]
+  (-> {}
+    (assoc :eid (-read-int conn))
+    (assoc :velocityx (-read-short conn))
+    (assoc :velocityy (-read-short conn))
+    (assoc :velocityz (-read-short conn))))
+
+(defn read-packet-entitydestroy [conn]
+  (-> {}
+    (assoc :eid (-read-int conn))))

 ; Reading Wrappers -----------------------------------------------------------------
@@ -506,6 +528,8 @@
         (= packet-type :mobspawn)             (read-packet-mobspawn conn)
         (= packet-type :entitypainting)       (read-packet-entitypainting conn)
         (= packet-type :stanceupdate)         (read-packet-stanceupdate conn)
+        (= packet-type :entityvelocity)       (read-packet-entityvelocity conn)
+        (= packet-type :entitydestroy)        (read-packet-entitydestroy conn)
         :else (str "UNKNOWN PACKET TYPE: " packet-id)
         ))
     (println "\n\n\n")))


fix typo

fix typo

--- dada-demo/src/main/clojure/org/dada/demo/server.clj
+++ dada-demo/src/main/clojure/org/dada/demo/server.clj
@@ -38,10 +38,10 @@
 	  ^javax.jms.Session jms-session (.createSession connection false (javax.jms.Session/DUPS_OK_ACKNOWLEDGE))
 	  num-threads 16		;TODO - hardwired
 	  timeout 10000			;TODO - hardwired
-	  ^ExecutorService thread (Executors/newFixedThreadPool num-threads)
+	  ^ExecutorService threads (Executors/newFixedThreadPool num-threads)
 	  ^MessageStrategy strategy (BytesMessageStrategy.)
 	  ^Translator translator (SerializeTranslator.)
-	  ^ServiceFactory service-factory (JMSServiceFactory. jms-session thread strategy translator timeout)]
+	  ^ServiceFactory service-factory (JMSServiceFactory. jms-session threads strategy translator timeout)]
       (def ^SessionManager session-manager (SessionManagerImpl. "SessionManager.POJO" service-factory *metamodel*)))

     ;; move this into SessionManagerImpl


Remove tests that refer to no longer existing fns

--- test/circle/backend/build/test_inference.clj
+++ test/circle/backend/build/test_inference.clj
@@ -2,14 +2,6 @@
   (:use midje.sweet)
   (:use circle.backend.build.inference)
   (:require [circle.backend.build.test-utils :as test]))
-
-(fact "repositories containing php files are assumed to be php apps"
-      (let [php-repo (test/test-repo "simple_php")]
-        (infer-repo-type php-repo) => :php))
-
-(fact "repositories that aren't php are assumed to be rails"
-      (let [some-repo (test/test-repo "empty")]
-        (infer-repo-type some-repo) => :rails))

 (fact "inferred actions have source :inferred"
   (let [example-repo (test/test-repo "database_yml_1")


[network] A version of train-until-error-stabilizes with a smaller interface.

--- cortex/src/cortex/nn/network.cljc
+++ cortex/src/cortex/nn/network.cljc
@@ -5,7 +5,8 @@
             [clojure.core.matrix.linear :as linear]
             [cortex.optimise :as opt]
             [cortex.nn.core :as core]
-            [cortex.util :as util]))
+            [cortex.util :as util]
+            [cortex.serialization :as cs]))

 #?(:clj (do
           (set! *warn-on-reflection* true)
@@ -149,3 +150,41 @@
             last-error epoch-error]
         (recur network optimizer mean-error-derivative last-error))
       network)))
+
+(defn simplified-train-until-error-stabilizes
+  [network training-data training-labels
+   & {:keys [optimizer loss-fn cv-data cv-labels batch-size noise-fn]
+      :or {optimizer (opt/adam)
+           loss-fn (opt/mse-loss)
+           cv-data training-data
+           cv-labels training-labels
+           batch-size 10}}]
+  (loop [network network
+         optimizer optimizer
+         mean-error-derivative -1.0
+         last-error 0.0]
+    (if (< mean-error-derivative 0.0)
+      (let [epoch-data (vec (partition batch-size batch-size [] (shuffle (range (count training-data)))))
+            [optimizer network]
+            (reduce (fn [[optimizer network] batch-indexes]
+                      (let [input-seq (mapv training-data batch-indexes)
+                            training-input (if noise-fn (mapv noise-fn input-seq) input-seq)
+                            answer-seq (mapv training-labels batch-indexes)
+                            [optimizer network] (train-batch input-seq
+                                                             answer-seq
+                                                             network optimizer loss-fn)]
+                        [optimizer network]))
+                    [optimizer network]
+                    epoch-data)
+            epoch-error (evaluate-mse network cv-data cv-labels)
+            _ (println "epoch error:" epoch-error)
+            _ (cs/write-network! network
+                                 (clojure.java.io/output-stream "last-network.bin"))
+            ;;While this error is smaller than last error, continue
+            epoch-derivative (if (= 0.0 last-error)
+                               (- epoch-error)
+                               (- epoch-error last-error))
+            mean-error-derivative (+ (* 0.8 mean-error-derivative) (* 0.2 epoch-derivative))
+            last-error epoch-error]
+        (recur network optimizer mean-error-derivative last-error))
+      network)))


Swapped some keys around.

Swapped some keys around.

--- src/lambda_blog/templates/rss.clj
+++ src/lambda_blog/templates/rss.clj
@@ -9,25 +9,25 @@
 (def _author author) ;; FIXME Loose the _.
 (def _summary summary)

-(defn rss-feed [{:keys [entries title url]}]
+(defn rss-feed [{:keys [entries root title]}]
   [(xml)
    (feed {:xmlns "http://www.w3.org/2005/Atom"}
          (tags/title title)
          (link {:rel :self
-                :href (path url "index.xml")})
-         (link {:href url})
+                :href (path root "index.xml")})
+         (link {:href root})
          (updated (now))
-         (id url)
-         (map (fn [{:keys [author filename path-to-root summary tags timestamp title]}]
+         (id root)
+         (map (fn [{:keys [author summary tags timestamp title url]}]
                 (entry (tags/title {:type :html}
                                    title)
-                       (id filename)
+                       (id url)
                        (_author (name author))
                        (updated timestamp)
                        (published timestamp)
-                       (link {:href (path path-to-root filename)})
+                       (link {:href url})
                        (map (fn [t]
-                              (category {:scheme (path url (format "/tags/%s.html" (url-encode t)))
+                              (category {:scheme (path root (format "/tags/%s.html" (url-encode t)))
                                          :term t
                                          :label t}))
                             tags)


throw only the root cause

throw only the root cause

--- src/co/nclk/flax/core.clj
+++ src/co/nclk/flax/core.clj
@@ -506,7 +506,7 @@
         exit (try
                (when-let [main (:main program)]
                  (doall (pmap #(evaluate % config) main)))
-               #_(catch java.util.concurrent.ExecutionException ae
+               (catch java.util.concurrent.ExecutionException ae
                  (loop [cause ae]
                    (if (nil? cause)
                      (throw ae)


Tidied up compojure.control, removed ifn and otherwise

--- src/compojure/control.clj
+++ src/compojure/control.clj
@@ -1,14 +1,17 @@
-;; Macros and functions for controling program flow
+;; Copyright (c) James Reeves. All rights reserved.
+;; The use and distribution terms for this software are covered by the Eclipse
+;; Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php) which
+;; can be found in the file epl-v10.html at the root of this distribution. By
+;; using this software in any fashion, you are agreeing to be bound by the
+;; terms of this license. You must not remove this notice, or any other, from
+;; this software.
+
+;; compojure.control:
+;;
+;; Various macros for controling program flow.
+
 (ns compojure.control
-  (:use (clojure.contrib seq-utils)))
-
-(def #^{:doc "Synonym for true; useful for ending conds"}
-  otherwise true)
-
-(defn ifn
-  "Equivalent to: (if (pred x) x (func x))"
-  [pred func x]
-  (if (pred x) x (func x)))
+  (:use clojure.contrib.seq-utils))

 (defmacro return
   "A do block that will always return the argument 'x'."
@@ -19,7 +22,7 @@
 (defmacro domap
   "Similar to doseq, but collects the results into a sequence."
   [[item list] & body]
-  `(map (fn [~item] ~@body) ~list))
+  `(map (fn [~item] ~@body) (doall ~list)))

 (defmacro redef
   "Redefine an existing value, keeping the metadata intact."


Use class instead of type for canonize multimethod.

--- src/puget/printer.clj
+++ src/puget/printer.clj
@@ -67,7 +67,7 @@
   [value]
   (if (satisfies? data/TaggedValue value)
     :tagged-value
-    (type value)))
+    (class value)))

 (defmulti canonize


Use illegal-when-strict in var printing.

--- src/puget/printer.clj
+++ src/puget/printer.clj
@@ -246,12 +246,9 @@

 ; TODO: regex/atom

-
 (defmethod canonize clojure.lang.Var
-  [v]
-  (when *strict-mode*
-    (throw (IllegalArgumentException.
-             (str "No canonical representation for " (class v) ": " v))))
+  [value]
+  (illegal-when-strict value)
   [:span
    (color-doc :delimiter "#'")
    (color-doc :symbol (subs (str v) 2))])


removed print statements for cleaner output

--- src/crawler/extractor.clj
+++ src/crawler/extractor.clj
@@ -97,7 +97,6 @@
   (let [sampled-uris     (sample
                           hrefs host (Math/ceil
                                       (/ (count hrefs) 4)))]
-    (println "Xpath:" xpath)
     (map
      (fn [sampled]
        (let [body             (visit-and-record-page sampled {:xpath xpath})
@@ -130,8 +129,7 @@
                                         (set (in-host-map xpath))
                                         (set (in-host-xpath-hrefs xpath)))))
                                     src-xpaths))]
-         (println "URI:" sampled)
-         (println similarity)
+
          (when xpaths-hrefs'
            (do
              (swap! *visited* conj sampled)


Changed time demo "simulated model changes" to 11am and 5pm so they are within the min and max range.

--- src/re_demo/time.cljs
+++ src/re_demo/time.cljs
@@ -97,9 +97,9 @@
                                            :gap "10px"
                                            :align :center
                                            :children [[button
-                                                       :label "7am"
+                                                       :label "11am"
                                                        :class "btn btn-xs"
-                                                       :on-click #(reset! an-int-time 700)]
+                                                       :on-click #(reset! an-int-time 1100)]
                                                       [button
                                                        :label "5pm"
                                                        :class "btn btn-xs"


do not modify the protocol just yet

do not modify the protocol just yet

--- src/riemann/index.clj
+++ src/riemann/index.clj
@@ -27,6 +27,8 @@
     "Return a seq of expired states from this index, removing each.")
   (search [this query-ast]
     "Returns a seq of events from the index matching this query AST")
+  (update [this event]
+    "Updates index with event")
   (lookup [this host service]
     "Lookup an indexed event from the index"))

@@ -64,6 +66,9 @@
               (let [matching (query/fun query-ast)]
                 (filter matching (.values hm))))

+      (update [this event]
+        (this event))
+
       (lookup [this host service]
         (.get hm [host service]))


Sort the list of applications

Sort the list of applications

--- src/onix/web.clj
+++ src/onix/web.clj
@@ -108,6 +108,7 @@
   []
   (->
    (persistence/list-applications)
+   sort
    (response json-content-type)))

 (defn- get-application


Remove long-since-obsolete dbg function

Remove long-since-obsolete dbg function

--- src/foreclojure/utils.clj
+++ src/foreclojure/utils.clj
@@ -17,9 +17,6 @@
   (fn [req]
     (binding [*url* (:uri req)]
       (handler req))))
-
-(defmacro dbg [x]
-  `(let [x# ~x] (println '~x "=" x#) x#))

 (defmacro assuming
   "Guard body with a series of tests. Each clause is a test-expression


Remove my bootlaces as a dependency

Remove my bootlaces as a dependency

--- build.boot
+++ build.boot
@@ -1,8 +1,7 @@
 (set-env!
  :resource-paths #{"resources"}
  :source-paths #{"src"}
- :dependencies '[[radicalzephyr/bootlaces  "0.1.14" :scope "test"]
-                 [radicalzephyr/boot-junit "0.2.1"  :scope "test"]
+ :dependencies '[[radicalzephyr/boot-junit "0.2.1"  :scope "test"]
                  [junit                    "4.12"   :scope "test"]])

 (def +version+ "0.1.0-SNAPSHOT")
@@ -10,7 +9,6 @@
 (require '[radicalzephyr.bootlaces  :refer :all]
          '[radicalzephyr.boot-junit :refer [junit]])

-(bootlaces! +version+)
 (set-env! :resource-paths #{}) ;; Must undo bootlaces! adding "src" to
                                ;; the resource-paths. Will be fixed in 0.1.15


Add reload port argument to dev boot task

--- build.boot
+++ build.boot
@@ -123,16 +123,18 @@

 (deftask dev
   "Run full dev environment."
-  [H host HOST str]
+  [_ reload-host HOST str "Reload WebSocket host"
+   _ reload-port PORT int "Reload WebSocket port"]
   (comp (serve)
         (repl)
         (watch)
-        (test)
+        ;(test)
         (build-html :metadata-file "perun.base.dev.edn")
         (build-css)
         (reload :on-jsload 'zetawar.core/run
                 :cljs-asset-path ""
-                :ws-host host)
+                :ws-host reload-host
+                :ws-port reload-port)
         (cljs-repl-env)
         (cljs :ids ["js/main"]
               :optimizations :none


Fix run-commands

Fix run-commands

--- build.boot
+++ build.boot
@@ -36,14 +36,19 @@
 (def windows?
   (.startsWith (.toLowerCase (System/getProperty "os.name")) "windows"))

-(defn run-commands
+(defn format-commands
   [& command-sets]
   (as-> command-sets c
         (map (partial concat (if windows? ["cmd" "/c"] ["sh" "-c"])) c)
         (interleave c (repeat (if windows? "&" ";")))
         (butlast c)
-        (flatten c)
-        (apply util/dosh c)))
+        (apply concat c)))
+
+(defn run-commands
+  [& command-sets]
+  (->> command-sets
+       (apply format-commands)
+       (apply util/dosh)))

 (deftask build
   "Builds the project."
@@ -188,9 +193,11 @@
     (target)
     (with-pass-thru _
       (host-process
-        (conch/proc "cmd" "/c" "lumo"
-                    "-c" (str "\"" (System/getProperty "fake.class.path") "\"")
-                    "-k" "lumo_cache"
-                    "-e" (str "\"(require '[mikron.core :as mikron "
-                              ":refer [schema defschema pack unpack gen valid?]])\"")
-                    "-r")))))
+        (apply conch/proc
+          (format-commands
+            ["lumo"
+             "-c" (str "\"" (System/getProperty "fake.class.path") "\"")
+             "-k" "lumo_cache"
+             "-e" (str "\"(require '[mikron.core :as mikron "
+                       ":refer [schema defschema pack unpack gen valid?]])\"")
+             "-r"]))))))


Improve log entry overflow printing

Improve log entry overflow printing

--- test/onyx/log/generators.clj
+++ test/onyx/log/generators.clj
@@ -125,7 +125,8 @@
               (let [g (gen/return state)]
                 (when (> (count (:log state))
                          1000)
-                  (throw (Exception. (str "Log entry generator overflow. Likely issue with uncompletable log\n" state))))
+                  (throw (Exception. (str "Log entry generator overflow. Likely issue with uncompletable log\n"
+                                          (with-out-str (clojure.pprint/pprint state))))))
                 (if (empty? (:entries state))
                   g
                   (apply-entries-gen (apply-entry-gen g)))))))


Version 1.2.2

Version 1.2.2

--- project.clj
+++ project.clj
@@ -1,4 +1,4 @@
-(defproject puppetlabs/http-client "1.2.2-SNAPSHOT"
+(defproject puppetlabs/http-client "1.2.2"
   :description "HTTP client wrapper"
   :license {:name "Apache License, Version 2.0"
             :url "http://www.apache.org/licenses/LICENSE-2.0.html"}


project: bump netty dependency

project: bump netty dependency

--- project.clj
+++ project.clj
@@ -25,4 +25,4 @@
                  [com.boundary/high-scale-lib   "1.0.6"]
                  [net.jpountz.lz4/lz4           "1.3"]
                  [org.xerial.snappy/snappy-java "1.1.2"]
-                 [io.netty/netty-all            "4.0.32.Final"]])
+                 [io.netty/netty-all            "4.0.34.Final"]])


(Maint) Update releases and snapshots repositories

The old repositories URLS were incorrect, which caused an error message when trying to start a REPL. The REPL now starts successfully.

--- project.clj
+++ project.clj
@@ -23,8 +23,8 @@
   :lein-release {:scm         :git
                  :deploy-via  :lein-deploy}

-  :repositories [["releases" "http://nexus.delivery.puppetlabs.net/content/repositories/releases/"]
-                 ["snapshots" "http://nexus.delivery.puppetlabs.net/content/repositories/snapshots/"]]
+  :repositories [["releases" "https://artifactory.delivery.puppetlabs.net/artifactory/clojure-releases__local/"]
+                 ["snapshots" "https://artifactory.delivery.puppetlabs.net/artifactory/clojure-snapshots__local/"]]

   :deploy-repositories [["releases" {:url "https://clojars.org/repo"
                                      :username :env/clojars_jenkins_username


Upgrades piggieback

Upgrades piggieback

--- project.clj
+++ project.clj
@@ -71,7 +71,7 @@
              }
   :profiles {:dev {:dependencies [[binaryage/devtools "0.9.2"]
                                   [figwheel-sidecar "0.5.14"]
-                                  [com.cemerick/piggieback "0.2.1"]
+                                  [com.cemerick/piggieback "0.2.2"]
                                   [orchestra "2017.07.04-1"]
                                   [org.clojure/core.specs.alpha "0.1.24"]
                                   [io.aviso/pretty "0.1.34"]


Ready to release

Ready to release

--- project.clj
+++ project.clj
@@ -1,6 +1,6 @@
 ;; Copyright © 2014 JUXT LTD.

-(defproject juxt/modular "0.3.1-SNAPSHOT"
+(defproject juxt/modular "0.3.1"
   :description "FIXME: write description"
   :url "http://github.com/mastodonc/kixi.stentor"
   :license {:name "The MIT License"


Add core.async dependency.

Add core.async dependency.

--- project.clj
+++ project.clj
@@ -3,16 +3,17 @@
   :url "http://example.com/FIXME"
   :license {:name "Eclipse Public License"
             :url "http://www.eclipse.org/legal/epl-v10.html"}
-  :dependencies [[org.clojure/clojure "1.6.0"]
+  :dependencies [[org.clojure/clojure       "1.6.0"]
                  [org.clojure/clojurescript "0.0-2760"]
-                 [org.omcljs/om "0.8.8"]
-                 [om-utils "0.4.0"]
+                 [org.omcljs/om             "0.8.8"]
+                 [om-utils                  "0.4.0"]
                  [org.clojure/tools.logging "0.3.1"]
-                 [http-kit "2.1.18"]
-                 [org.clojure/data.json "0.2.6"]
-                 [quil "2.2.6"]
-                 [overtone "0.9.1"]
-                 [clojurewerkz/quartzite "2.0.0"]]
+                 [http-kit                  "2.1.18"]
+                 [org.clojure/data.json     "0.2.6"]
+                 [quil                      "2.2.6"]
+                 [overtone                  "0.9.1"]
+                 [clojurewerkz/quartzite    "2.0.0"]
+                 [org.clojure/core.async    "0.1.346.0-17112a-alpha"]]
   :plugins [[lein-cljsbuild "1.0.6"]]
   :cljsbuild {:builds [{:id           "dev"
                         :source-paths ["src/clu/gui"]


temporary fix for heroku

temporary fix for heroku

--- project.clj
+++ project.clj
@@ -47,14 +47,12 @@

   :plugins [[lein-environ "1.0.0"]
             [migratus-lein "0.1.7"]
-            [lein-cljsbuild "1.0.6"]
-            [lein-sassc "0.10.4"]]
+            [lein-cljsbuild "1.0.6"]]
   :sassc [{:src "resources/scss/screen.scss"
            :output-to "resources/public/css/screen.css"
            :style "nested"
            :import-path "resources/scss"}]

-  :hooks [leiningen.sassc]
   :clean-targets ^{:protect false} [:target-path [:cljsbuild :builds :app :compiler :output-dir] [:cljsbuild :builds :app :compiler :output-to]]
   :cljsbuild
   {:builds


Release 0.7.5.2

Release 0.7.5.2

--- project.clj
+++ project.clj
@@ -1,4 +1,4 @@
-(defproject onyx-app/lein-template "0.7.5.2-SNAPSHOT"
+(defproject onyx-app/lein-template "0.7.5.2"
   :description "Onyx Leiningen application template"
   :url "https://github.com/onyx-platform/onyx-template"
   :license {:name "Eclipse Public License"


lein-release plugin: bumped version from 0.2.1 to 0.2.2-SNAPSHOT for next development cycle

--- project.clj
+++ project.clj
@@ -1,4 +1,4 @@
-(defproject de.otto/tesla-jetty "0.2.1"
+(defproject de.otto/tesla-jetty "0.2.2-SNAPSHOT"
   :description "basic microservice."
   :url "https://github.com/otto-de/tesla-jetty"
   :license {:name "Apache License 2.0"


Bump version for development.

Bump version for development.

--- project.clj
+++ project.clj
@@ -1,4 +1,4 @@
-(defproject org.toomuchcode/clara-rules "0.9.2"
+(defproject org.toomuchcode/clara-rules "0.10.0-SNAPSHOT"
   :description "Clara Rules Engine"
   :url "https://github.com/rbrush/clara-rules"
   :license {:name "Eclipse Public License"


Add option to run in proxied mode

Add option to run in proxied mode

--- project.clj
+++ project.clj
@@ -11,6 +11,10 @@
                            [clj-oauth2 "0.2.0"]
                            [cheshire "5.4.0"]
                            ]
+
+            :profiles {:proxied
+                       {:jvm-opts ["-Dhttp.proxyHost=127.0.0.1" "-Dhttp.proxyPort=8888" "-Dhttps.proxyHost=127.0.0.1" "-Dhttps.proxyPort=8888"]}}
             :plugins [[lein-ring "0.9.1"]]
             :ring {:handler checkin.handler/app
-                   :uberwar-name "loneworkercheckin.war"})
+                   :uberwar-name "loneworkercheckin.war"}
+            :aliases {"run-proxied" ["with-profile" "proxied" "ring" "server"]})


Prepare for next release cycle.

Prepare for next release cycle.

--- project.clj
+++ project.clj
@@ -1,4 +1,4 @@
-(defproject org.onyxplatform/onyx-dashboard "0.9.7.1"
+(defproject org.onyxplatform/onyx-dashboard "0.9.7.2-SNAPSHOT"
   :description "Dashboard for the Onyx distributed computation system"
   :url "http://github.com/lbradstreet/onyx-dashboard"
   :license {:name "Eclipse Public License"


Reformatting

Reformatting

--- project.clj
+++ project.clj
@@ -41,50 +41,65 @@

   :minify-assets
   {:assets
-    {"resources/public/css/site.min.css" "resources/public/css/site.css"}}
+    {"resources/public/css/site.min.css"
+     "resources/public/css/site.css"}}

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

-  :profiles {:dev {:repl-options {:init-ns decktouch.handler
-                                  :nrepl-middleware [cemerick.piggieback/wrap-cljs-repl]}
+  :profiles {
+    :dev {
+      :repl-options {
+        :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 {:source-map true}}}}}
+        :cljsbuild {
+          :builds {
+            :app {
+              :source-paths ["env/dev/cljs"]
+              :compiler {:output-to "resources/public/js/app.js"
+              :source-map true}}}}}

-             :uberjar {:hooks [leiningen.cljsbuild minify-assets.plugin/hooks]
-                       :env {:production true}
-                       :aot :all
-                       :omit-source true
-                       :cljsbuild {:jar true
-                                   :builds {:app
-                                             {:source-paths ["env/prod/cljs"]
-                                              :compiler
-                                              {:optimizations :advanced
-                                               :pretty-print false}}}}}
+    :uberjar {
+      :hooks [leiningen.cljsbuild minify-assets.plugin/hooks]
+      :env {:production true}
+      :aot :all
+      :omit-source true
+      :cljsbuild {:jar true
+                  :builds {
+                    :app {:source-paths ["env/prod/cljs"]
+                          :compiler {
+                            :optimizations :advanced
+                            :pretty-print false}}}}}

-             :production {:ring {:open-browser? false
-                                 :stacktraces?  false
-                                 :auto-reload?  false}}})
+    :production {
+      :ring {
+        :open-browser? false
+        :stacktraces?  false
+        :auto-reload?  false}}})


lein-release plugin: bumped version from 0.55 to 0.56-SNAPSHOT for next development cycle

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


Version 2.1.4-SNAPSHOT

Version 2.1.4-SNAPSHOT

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


(MAINT) Bump lein-ezbake dependency to 0.3.3

This commit bumps the puppet-server lein-ezbake dependency to 0.3.3,
needed to avoid Fedora 19 being used as a build target since that's now
been removed for our packaging jobs.

--- project.clj
+++ project.clj
@@ -98,7 +98,7 @@
              :ezbake {:dependencies ^:replace [[puppetlabs/puppetserver ~ps-version]
                                                [puppetlabs/trapperkeeper-webserver-jetty9 ~tk-jetty-version]
                                                [org.clojure/tools.nrepl "0.2.3"]]
-                      :plugins [[puppetlabs/lein-ezbake "0.3.2"]]
+                      :plugins [[puppetlabs/lein-ezbake "0.3.3"]]
                       :name "puppetserver"}
              :uberjar {:aot [puppetlabs.trapperkeeper.main]
                        :dependencies [[puppetlabs/trapperkeeper-webserver-jetty9 ~tk-jetty-version]]}


Make this dep explicit

Make this dep explicit

--- project.clj
+++ project.clj
@@ -4,6 +4,7 @@
   :license {:name "Eclipse Public License"
             :url "http://www.eclipse.org/legal/epl-v10.html"}
   :dependencies [[org.clojure/clojure "1.4.0"]
+                 [org.clojure/tools.logging "0.2.6"]
                  [ring/ring-core "1.2.0"]
                  [com.h2database/h2 "1.3.160"]
                  [org.clojure/java.jdbc "0.3.0-alpha4"]


Version 4.0.0-alpha3

Version 4.0.0-alpha3

--- project.clj
+++ project.clj
@@ -1,10 +1,10 @@
-(defproject neko "4.0.0-SNAPSHOT"
+(defproject neko "4.0.0-alpha3"
   :description "Neko is a toolkit designed to make Android development using Clojure easier and more fun."
   :url "https://github.com/clojure-android/neko"
   :license {:name "Eclipse Public License"
             :url "http://www.eclipse.org/legal/epl-v10.html"}

-  :dependencies [[org.clojure-android/clojure "1.7.0-beta3-r2"]
+  :dependencies [[org.clojure-android/clojure "1.7.0-r2"]
                  [com.android.support/multidex "1.0.0" :extension "aar"]]
   :plugins [[lein-droid "0.4.1-SNAPSHOT"]]


update version

update version

--- project.clj
+++ project.clj
@@ -1,4 +1,4 @@
-(defproject domshot "0.0.1"
+(defproject domshot "0.1.0"
   :description "Take a snapshot of your dom, a domshot"
   :url "https://github.com/dillonforrest/domshot"


build

build

--- project.clj
+++ project.clj
@@ -13,7 +13,6 @@
   :java-source-paths ["src/java"]
   :javac-options ["-Xlint:unchecked"]
   :jar-exclusions [#".gitignore"]
-  :exclusions [log4j/log4j]
   :dependencies [[org.clojure/clojure "1.8.0"]

                  ;; command line


Version 0.0.9

Version 0.0.9

--- project.clj
+++ project.clj
@@ -1,4 +1,4 @@
-(defproject day8.re-frame/abra "0.0.9-SNAPSHOT"
+(defproject day8.re-frame/abra "0.0.9"
   :description "Tracing and developer tools for re-frame apps"
   :url         "https://github.com/Day8/re-frame-trace"
   :license     {:name "MIT"}


updated solr deps

updated solr deps

--- project.clj
+++ project.clj
@@ -17,7 +17,7 @@
                  [korma "0.4.0"]
                  [org.xerial/sqlite-jdbc "3.7.15-M1"]
                  [pegasus "0.7.0"]
-                 [clj-solr "1.0"]]
+                 [clj-solr "1.1"]]
   :main elliot.server)


project.clj for version 0.1.0

project.clj for version 0.1.0

--- project.clj
+++ project.clj
@@ -1,4 +1,4 @@
-(defproject infinitelives/infinitelives.pixi "0.1.0-SNAPSHOT"
+(defproject infinitelives/infinitelives.pixi "0.1.0"
   :description "2D pixi library for rapidly developing games in clojurescript"
   :url "https://github.com/infinitelives/infinitelives.pixi"
   :license {:name "Eclipse Public License"
@@ -8,7 +8,7 @@
                  [org.clojure/core.async "0.1.346.0-17112a-alpha"]

                  ;; depend on utils
-                 [infinitelives/infinitelives.utils "0.1.0-SNAPSHOT"]
+                 [infinitelives/infinitelives.utils "0.1.0"]

                  ;; we need pixi
                  [cljsjs/pixi "3.0.7-0"]


Inc version and compile to a specific source and such.

--- project.clj
+++ project.clj
@@ -1,5 +1,9 @@
-(defproject io "0.2.0"
+(defproject io "0.2.1"
   :description "The innermost moon of Jupiter."
+  :url "https://github.com/flatland/io"
+  :license  {:name "Eclipse Public License - v 1.0"
+            :url "http://www.eclipse.org/legal/epl-v10.html"}
   :dependencies [[org.clojure/clojure "1.3.0"]]
   :java-source-paths ["src/java"]
-  :source-paths ["src/clj"])
+  :source-paths ["src/clj"]
+  :javac-options ["-target" "1.5" "-source" "1.5"])


Fix description and url in project file

Fix description and url in project file

--- project.clj
+++ project.clj
@@ -1,6 +1,6 @@
 (defproject gol "0.1.0-SNAPSHOT"
-  :description "FIXME: write this!"
-  :url "http://example.com/FIXME"
+  :description "Conway's Game of Life"
+  :url "http://pavel-v-chernykh.github.io/gol/"

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


Upgrade binaryage/devtools to 0.9.11

Upgrade binaryage/devtools to 0.9.11

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

   :profiles {:debug {:debug true}
              :dev   {:dependencies [[karma-reporter     "3.1.0"]
-                                    [binaryage/devtools "0.9.10"]]
+                                    [binaryage/devtools "0.9.11"]]
                      :plugins      [[lein-ancient "0.6.15"]
                                     [lein-shell   "0.5.0"]]}}


test.check is a dev dependency

test.check is a dev dependency

--- project.clj
+++ project.clj
@@ -3,7 +3,8 @@
   :url "https://github.com/gfredericks/seventy-one"
   :license {:name "Eclipse Public License"
             :url "http://www.eclipse.org/legal/epl-v10.html"}
-  :dependencies [[org.clojure/clojure "1.7.0-RC1"]
-                 [org.clojure/test.check "0.7.0"]]
+  :dependencies [[org.clojure/clojure "1.7.0-RC1"]]
+  :profiles {:dev {:dependencies
+                   [[org.clojure/test.check "0.7.0"]]}}
   :plugins [[codox "0.8.12"]]
   :deploy-repositories [["releases" :clojars]])


update leiningen deps

update leiningen deps

--- project.clj
+++ project.clj
@@ -3,11 +3,8 @@
   :source-paths ["src/main/clojure"]
   :test-paths ["src/test/clojure"]

-  :dependencies [[org.clojure/clojure "1.5.1"]
+  :dependencies [[org.clojure/clojure "1.7.0-alpha5"]
                  [overtone "0.9.1"]
-                 [net.mikera/vectorz-clj "0.17.0"]
-                 [net.mikera/vectorz "0.25.0"]
-                 [net.mikera/core.matrix "0.16.0"]
-                 [net.mikera/cljunit "0.3.0"]
-                 [net.mikera/imagez "0.3.1"]]
+                 [net.mikera/vectorz-clj "0.29.0"]
+                 [net.mikera/imagez "0.5.0"]]
   :jvm-opts ["-Xmx2048m"])


Update version info.

Update version info.

--- project.clj
+++ project.clj
@@ -1,5 +1,5 @@
-;(defproject cli4clj "0.7.0"
-(defproject cli4clj "0.7.1-SNAPSHOT"
+(defproject cli4clj "0.8.0"
+;(defproject cli4clj "0.8.1-SNAPSHOT"
   :description "Create simple interactive CLIs for Clojure applications."
   :url "https://github.com/ruedigergad/cli4clj"
   :license {:name "Eclipse Public License"


Version 0.4.34

Version 0.4.34

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


Version 0.1.3

Version 0.1.3

--- project.clj
+++ project.clj
@@ -7,7 +7,7 @@
 (defn relative-path [path]
     (expand-path (str (dirname *file*) "/" path)))

-(defproject riemann "0.1.3-SNAPSHOT"
+(defproject riemann "0.1.3"
   :description
 "A network event stream processor. Intended for analytics, metrics, and alerting; and to glue various monitoring systems together."
   :url "http://github.com/aphyr/riemann"
@@ -40,7 +40,7 @@
     [clj-http "0.4.1"]
     [clj-json "0.5.0"]
     [clj-time "0.4.3"]
-    [clj-librato "0.0.2-SNAPSHOT"]
+    [clj-librato "0.0.2"]
     [incanter/incanter-charts "1.3.0"]
   ]
   :plugins [[codox "0.6.1"]]


Removed unused dep.

Removed unused dep.

--- project.clj
+++ project.clj
@@ -27,7 +27,6 @@
     [clojusc/trifl "0.2.0"]
     [clojusc/twig "0.3.2"]
     [com.stuartsierra/component "0.3.2"]
-    [gov.nasa.earthdata/cmr-client "0.3.0-SNAPSHOT"]
     [http-kit "2.2.0"]
     [metosin/reitit-core "0.1.1-SNAPSHOT"]
     [metosin/reitit-ring "0.1.1-SNAPSHOT"]


Prepare 3.0.0-beta7 release

Prepare 3.0.0-beta7 release

--- project.clj
+++ project.clj
@@ -1,4 +1,4 @@
-(defproject neko "3.0.0-SNAPSHOT"
+(defproject neko "3.0.0-beta7"
   :description "Neko is a toolkit designed to make Android development using Clojure easier and more fun."
   :url "https://github.com/alexander-yakushev/neko"
   :license {:name "Eclipse Public License"


remove weasel

remove weasel

--- project.clj
+++ project.clj
@@ -28,16 +28,13 @@
                  [com.facebook/react "0.11.2"]
                  [facts/speech-synthesis "1.0.0"]
                  [clj-time "0.8.0"]
-                 [aprint "0.1.1"]
-                 [weasel "0.4.2"]]
+                 [aprint "0.1.1"]]

   :source-paths ["src/cljs" "src/clj"]

   :min-lein-version "2.0.0"

   :main lesezeichen.core
-
-  :repl-options {:nrepl-middleware [cemerick.piggieback/wrap-cljs-repl]}

   :plugins [[lein-cljsbuild "1.0.3"]
             [lein-figwheel "0.1.4-SNAPSHOT"]]


Version 0.1.1-SNAPSHOT

Version 0.1.1-SNAPSHOT

--- project.clj
+++ project.clj
@@ -1,4 +1,4 @@
-(defproject jcf/lein-template "0.1.0"
+(defproject jcf/lein-template "0.1.1-SNAPSHOT"
   :description "FIXME: write description"
   :url "https://github.com/jcf/lein-template"
   :license {:name "The MIT License"


Update liberator.

Update liberator.

--- project.clj
+++ project.clj
@@ -24,7 +24,7 @@
     [ring/ring-core "1.6.1"] ; Web application library https://github.com/ring-clojure/ring
     [http-kit "2.3.0-alpha2"] ; Web Server http://http-kit.org/
     [compojure "1.6.0"] ; Web routing https://github.com/weavejester/compojure
-    [liberator "0.14.1"] ; WebMachine (REST API server) port to Clojure https://github.com/clojure-liberator/liberator
+    [liberator "0.15.0"] ; WebMachine (REST API server) port to Clojure https://github.com/clojure-liberator/liberator
     [com.ashafa/clutch "0.4.0"] ; CouchDB client https://github.com/clojure-clutch/clutch
     [clojurewerkz/elastisch "3.0.0-beta2"] ; Client for ElasticSearch https://github.com/clojurewerkz/elastisch
     [environ "1.1.0"] ; Get environment settings from different sources https://github.com/weavejester/environ


(maint) Bump version to 0.5.0-SNAPSHOT

(maint) Bump version to 0.5.0-SNAPSHOT

--- project.clj
+++ project.clj
@@ -2,7 +2,7 @@
 (def ks-version "1.3.0")

-(defproject puppetlabs/trapperkeeper-status "0.4.1-SNAPSHOT"
+(defproject puppetlabs/trapperkeeper-status "0.5.0-SNAPSHOT"
   :description "A trapperkeeper service for getting the status of other trapperkeeper services."
   :url "https://github.com/puppetlabs/trapperkeeper-status"
   :license {:name "Apache License, Version 2.0"


bumped up dependencies, version

bumped up dependencies, version

--- project.clj
+++ project.clj
@@ -1,14 +1,14 @@
-(defproject selmer "1.11.8"
+(defproject selmer "1.11.9"
   :description "Django style templates for Clojure"
   :url "https://github.com/yogthos/Selmer"
   :license {:name "Eclipse Public License"
             :url "http://www.eclipse.org/legal/epl-v10.html"}
   :dependencies [[org.clojure/clojure "1.9.0"]
                  [criterium "0.4.4" :scope "test"]
-                 [joda-time "2.9.6"]
-                 [commons-codec "1.10"]
-                 [json-html "0.4.0"]
-                 [cheshire "5.6.3"]]
+                 [joda-time "2.10"]
+                 [commons-codec "1.11"]
+                 [json-html "0.4.4"]
+                 [cheshire "5.8.0"]]

   :aot [selmer.node]
   :javac-options ["-target" "1.6"]


Remove unused Korma dependency

Remove unused Korma dependency


1.3.0-beta6

--- project.clj
+++ project.clj
@@ -1,4 +1,4 @@
-(defproject clojurewerkz/cassaforte "1.3.0-beta6-SNAPSHOT"
+(defproject clojurewerkz/cassaforte "1.3.0-beta6"
   :min-lein-version "2.0.0"
   :description "A Clojure client for Apache Cassandra"
   :url "http://clojurecassandra.info"


Update dependencies.

Update dependencies.

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

   :dependencies [[org.clojure/clojure "1.8.0" :scope "provided"]
                  [org.clojure/clojurescript "1.9.946" :scope "provided"]
-                 [io.reactivex.rxjava2/rxjava "2.1.6"]]
+                 [io.reactivex.rxjava2/rxjava "2.1.12"]]

   :deploy-repositories {"releases" :clojars
                         "snapshots" :clojars}
@@ -26,7 +26,7 @@
          :aliases {"test-all" ["with-profile" "dev,1.9:dev,1.7:dev" "test"]}
          :global-vars {*warn-on-reflection* false}
          :plugins [[funcool/codeina "0.5.0"]
-                   [lein-ancient "0.6.10"]]}
-   :1.9 {:dependencies [[org.clojure/clojure "1.9.0-rc1"]]}
+                   [lein-ancient "0.6.15"]]}
+   :1.9 {:dependencies [[org.clojure/clojure "1.9.0"]]}
    :1.7 {:dependencies [[org.clojure/clojure "1.7.0"]]}})


lein-release plugin: bumped version from 0.75 to 0.76-SNAPSHOT for next development cycle

--- project.clj
+++ project.clj
@@ -1,4 +1,4 @@
-(defproject exploud "0.75"
+(defproject exploud "0.76-SNAPSHOT"
   :description "Exploud service"
   :url "http://wikis.in.nokia.com/NokiaMusicArchitecture/Exploud"


Version 2.1.2-SNAPSHOT

Version 2.1.2-SNAPSHOT

--- project.clj
+++ project.clj
@@ -1,4 +1,4 @@
-(defproject puppetlabs/http-client "2.1.1"
+(defproject puppetlabs/http-client "2.1.2-SNAPSHOT"
   :description "HTTP client wrapper"
   :license {:name "Apache License, Version 2.0"
             :url "http://www.apache.org/licenses/LICENSE-2.0.html"}


Removed testing deps.

Removed testing deps.

--- project.clj
+++ project.clj
@@ -49,10 +49,7 @@
     :local {
       :dependencies [
         [org.clojure/tools.namespace "0.2.11"]
-        [proto-repl "0.3.1"]
-        [me.delete/plugin-a "0.1.0-SNAPSHOT"]
-        [me.delete/plugin-b "0.1.0-SNAPSHOT"]
-        [me.delete/plugin-c "0.1.0-SNAPSHOT"]]
+        [proto-repl "0.3.1"]]
       :plugins [
         [lein-project-version "0.1.0"]
         [lein-shell "0.5.0"]


upgrade sablono

upgrade sablono

--- project.clj
+++ project.clj
@@ -21,13 +21,14 @@
                  [environ "1.0.0"]
                  [http-kit "2.1.19"]
                  [prismatic/om-tools "0.3.10"]
-                 [sablono "0.2.22"]
+                 [sablono "0.3.4"]
                  [cljs-http "0.1.30"]
                  [org.clojure/core.async "0.1.346.0-17112a-alpha"]
                  [clojurewerkz/elastisch "2.1.0"]]

   :plugins [[lein-cljsbuild "1.0.5"]
-            [lein-environ "1.0.0"]]
+            [lein-environ "1.0.0"]
+            [lein-pprint "1.1.1"]]

   :min-lein-version "2.5.0"

@@ -81,4 +82,4 @@
                                              {:optimizations :whitespace ;:advanced
                                               :pretty-print true ;false
                                               }}}}}}
-  :main searchbot.server)
+  )


release 2.7.4

release 2.7.4

--- project.clj
+++ project.clj
@@ -1,4 +1,4 @@
-(defproject babel "2.7.4-SNAPSHOT"
+(defproject babel "2.7.4"
   :description "A library for natural language generation and parsing"
   :url "http://github.com/ekoontz/babel"
   :license {:name "Eclipse Public License"


Version 0.12.0-SNAPSHOT

Version 0.12.0-SNAPSHOT

--- project.clj
+++ project.clj
@@ -1,4 +1,4 @@
-(defproject crucible "0.11.2"
+(defproject crucible "0.12.0-SNAPSHOT"
   :description "AWS Cloudformation templates in Clojure"
   :url "http://github.com/brabster/crucible"
   :license {:name "Eclipse Public License"


Version 0.10.9-SNAPSHOT

Version 0.10.9-SNAPSHOT

--- project.clj
+++ project.clj
@@ -1,4 +1,4 @@
-(defproject re-frame "0.10.8"
+(defproject re-frame "0.10.9-SNAPSHOT"
   :description  "A Clojurescript MVC-like Framework For Writing SPAs Using Reagent."
   :url          "https://github.com/Day8/re-frame.git"
   :license      {:name "MIT"}


version upgrade

version upgrade

--- project.clj
+++ project.clj
@@ -3,7 +3,7 @@
   :dependencies [[org.clojure/clojure "1.5.1"]
                  [hiccup "1.0.0"]
                  [cheshire "5.3.1"]
-                 [ring/ring-core "1.1.0"]
+                 [ring/ring-core "1.2.1"]
                  [com.taoensso/carmine "2.4.4"]
                  [compojure "1.1.6"]]
   :min-lein-version "2.0.0"


use bugfix version of clojure commons

use bugfix version of clojure commons

--- project.clj
+++ project.clj
@@ -4,7 +4,7 @@
   :pedantic? :warn
   :dependencies [[org.clojure/clojure "1.6.0"]
                  [marick/suchwow "2.0.0" :exclusions [org.clojure/clojure]]
-                 [marick/clojure-commons "0.7.0" :exclusions [org.clojure/clojure]]
+                 [marick/clojure-commons "0.7.1" :exclusions [org.clojure/clojure]]
                  ;; upgrading to 1.3.2 produces record-type output for ordered maps
                  [ordered "1.2.0" :exclusions [org.clojure/clojure]]
                  [org.clojure/math.combinatorics "0.1.1"]


Version 3.0.5

Version 3.0.5

--- project.clj
+++ project.clj
@@ -1,4 +1,4 @@
-(defproject dda/dda-managed-ide "3.0.5-SNAPSHOT"
+(defproject dda/dda-managed-ide "3.0.5"
   :description "module to install and configure ide based on ubuntu vm."
   :url "https://www.domaindrivenarchitecture.org"
   :license {:name "Apache License, Version 2.0"