moving generation code around

moving generation code around

--- src/babel/generate.cljc
+++ src/babel/generate.cljc
@@ -30,7 +30,6 @@
 (declare lexemes-before-phrases)
 (declare lightning-bolts)
 (declare generate-all)
-(declare in-case-of-no-phrasal-complements)
 (declare path-to-map)
 (declare show-bolt)
 (declare truncate)
@@ -47,7 +46,7 @@
                 (first (take 1
                              (lazy-mapcat (fn [each-spec]
                                            (log/info (str "generate: generating from spec: "
-                                                          each-spec))
+                                                          (strip-refs each-spec) " with max-total-depth: " max-total-depth))
                                            (let [expressions
                                                  (generate-all each-spec grammar lexicon index morph 0
                                                                :max-total-depth max-total-depth
@@ -71,7 +70,7 @@
         true
         (do
           (log/info (str "generate: generating from spec: "
-                         (strip-refs spec)))
+                         (strip-refs spec) " with max-total-depth: " max-total-depth))
           (let [expression (first (take 1 (generate-all spec grammar lexicon index morph 0
                                                         :max-total-depth max-total-depth
                                                         :truncate-children truncate-children)))]
@@ -86,17 +85,22 @@
                                 (unifyc
                                  spec
                                  {:synsem {:sem (strip-refs (get-in expression [:synsem :sem]))}}))))
-              (log/info (str "generate: no expression could be generated for spec:" (strip-refs spec))))
+              (log/warn (str "generate: no expression could be generated for spec:" (strip-refs spec))))
             expression))))

 (declare add-complements-to-bolts)
+(declare add-all-comps)
+(declare candidate-parents)
+(declare lazy-shuffle)

 (defn generate-all [spec grammar lexicon index morph total-depth
                     & {:keys [max-total-depth truncate-children]
                        :or {max-total-depth max-total-depth
                             truncate-children true}}]
-  (log/trace (str "generate-all: generating from spec with cat " (get-in spec [:synsem :cat])))
-  (log/debug (str "generate-all: generating from spec with spec " (strip-refs spec) "; max total depth: " max-total-depth))
+  (log/trace (str "generate-all: generating from spec with cat "
+                  (get-in spec [:synsem :cat])))
+  (log/debug (str "generate-all: generating from spec with spec "
+                  (strip-refs spec) "; max total depth: " max-total-depth))

   (let [total-depth (if total-depth total-depth 0)]
     (map (fn [expr]
@@ -104,52 +108,10 @@
              (truncate expr [[:head][:comp]])
              ;; else, don't truncate for efficiency (i.e. don't remove :head and :comp)
              expr))
-         (-> (lightning-bolts grammar lexicon spec 0 index morph total-depth :max-total-depth max-total-depth)
-             ;; TODO: allow more than a fixed maximum depth of generation (here, 4 levels from top of tree).
-             (add-complements-to-bolts [:head :head :head :comp] grammar lexicon index morph total-depth
-                                       :max-total-depth max-total-depth)
-             (add-complements-to-bolts [:head :head :comp] grammar lexicon index morph total-depth
-                                       :max-total-depth max-total-depth)
-             (add-complements-to-bolts [:head :comp] grammar lexicon index morph total-depth
-                                       :max-total-depth max-total-depth)
-             (add-complements-to-bolts [:comp] grammar lexicon index morph total-depth
-                                       :max-total-depth max-total-depth)))))
-
-(defn add-complements-to-bolts [bolts path grammar lexicon index morph total-depth
-                                & {:keys [max-total-depth]
-                                   :or {max-total-depth max-total-depth}}]
-  (lazy-mapcat
-   (fn [bolt]
-     (if (not (= :none (get-in bolt path :none)))
-      (do
-        (log/debug (str "add-complements-to-bolts@" path))
-        (let [add-complement add-complement]
-          (add-complement bolt path :top grammar lexicon index morph 0 (+ total-depth (count path))
-                          :max-total-depth max-total-depth)))
-      [bolt]))
-   bolts))
-
-(defn candidate-parents [rules spec]
-  "find subset of _rules_ for which each member unifies successfully with _spec_"
-  (log/trace (str "candidate-parents: spec: " (strip-refs spec)))
-  (filter #(not (fail? %))
-          (mapfn (fn [rule]
-                   (if (and (not (fail? (unifyc (get-in rule [:synsem :cat] :top)
-                                                (get-in spec [:synsem :cat] :top))))
-                            (not (fail? (unifyc (get-in rule [:synsem :infl] :top)
-                                                (get-in spec [:synsem :infl] :top))))
-                            (not (fail? (unifyc (get-in rule [:synsem :sem :tense] :top)
-                                                (get-in spec [:synsem :sem :tense] :top))))
-                            (not (fail? (unifyc (get-in rule [:synsem :modified] :top)
-                                                (get-in spec [:synsem :modified] :top)))))
-                     (unifyc spec rule)
-                     :fail))
-                 rules)))
-
-(declare morph-with-recovery)
-
-(defn lazy-shuffle [seq]
-  (lazy-seq (shuffle seq)))
+         (->
+          (lightning-bolts grammar lexicon spec 0 index morph total-depth :max-total-depth max-total-depth)
+          (add-all-comps (take max-total-depth (repeatedly (fn [] :head)))
+                         grammar lexicon index morph total-depth)))))

 (defn lightning-bolts [grammar lexicon spec depth index morph total-depth
                        & {:keys [max-total-depth]
@@ -177,10 +139,100 @@
                                        (lightning-bolts grammar lexicon (get-in parent [:head])
                                                         (+ 1 depth) index morph (+ 1 total-depth)
                                                         :max-total-depth max-total-depth)))
-                         parents))]
+                         parents)
+            (do
+              (log/info (str "hit max-total-depth: " max-total-depth ": will not generate phrasal head children."))
+              nil))]
       (if (lexemes-before-phrases total-depth)
         (lazy-cat lexical phrasal)
         (lazy-cat phrasal lexical)))))
+
+(defn add-all-comps [bolts path grammar lexicon index morph total-depth]
+  (if (not (empty? path))
+    (add-all-comps
+     (add-complements-to-bolts bolts (concat path [:comp])
+                               grammar lexicon index morph total-depth
+                               :max-total-depth max-total-depth)
+     (rest path) grammar lexicon index morph total-depth)
+    (add-complements-to-bolts bolts [:comp]
+                              grammar lexicon index morph total-depth)))
+
+(defn add-complements-to-bolts [bolts path grammar lexicon index morph total-depth
+                                & {:keys [max-total-depth]
+                                   :or {max-total-depth max-total-depth}}]
+  (lazy-mapcat
+   (fn [bolt]
+     (if (not (= :none (get-in bolt path :none)))
+       (add-complement bolt path :top grammar lexicon index morph 0 (+ total-depth (count path))
+                       :max-total-depth max-total-depth)
+       (do
+         (log/warn (str "bolt has no path: " (string/join " " path)))
+         [bolt])))
+   bolts))
+
+(defn add-complement [bolt path spec grammar lexicon index morph depth total-depth
+                      & {:keys [max-total-depth]
+                         :or {max-total-depth max-total-depth}}]
+  (log/debug (str "add-complement: start: " (show-bolt bolt path morph) "@" path))
+  (let [input-spec spec
+        from-bolt bolt ;; so we can show what (add-complement) did to the input bolt, for logging.
+        spec (unifyc spec (get-in bolt path))
+        immediate-parent (get-in bolt (butlast path))
+        complement-candidate-lexemes
+        (if (not (= true
+                    (get-in bolt (concat path [:phrasal]))))
+          (let [indexed (if index
+                         (get-lex immediate-parent :comp index spec))]
+            (if indexed indexed
+                (flatten (vals lexicon)))))
+
+        complement-pre-check (fn [child parent path-to-child]
+                               (let [child-in-bolt (get-in bolt path-to-child)]
+                                 (not (fail?
+                                       (unifyc (get-in child [:synsem] :top)
+                                               (get-in child-in-bolt [:synsem] :top))))))
+
+        filtered-lexical-complements (filter (fn [lexeme]
+                                               (complement-pre-check lexeme bolt path))
+                                             complement-candidate-lexemes)]
+    (filter #(not (fail? %))
+            (mapfn (fn [complement]
+                    (unify (copy bolt)
+                           (path-to-map path
+                                        (copy complement))))
+                  (let [debug (log/trace (str "add-complement(depth=" depth ",total-depth=" total-depth
+                                              ",path=" path ",bolt=(" (show-bolt bolt path morph)
+                                              "): calling generate-all(" (strip-refs spec) ");"
+                                              "input-spec: " input-spec))
+                        phrasal-complements (if (and (> max-total-depth total-depth)
+                                                     (= true (get-in spec [:phrasal] true)))
+                                              (generate-all spec grammar lexicon index morph (+ depth total-depth)
+                                                            :max-total-depth max-total-depth))]
+                    (if (lexemes-before-phrases total-depth)
+                      (lazy-cat (lazy-shuffle filtered-lexical-complements) phrasal-complements)
+                      (lazy-cat phrasal-complements (lazy-shuffle filtered-lexical-complements))))))))
+
+(defn candidate-parents [rules spec]
+  "find subset of _rules_ for which each member unifies successfully with _spec_"
+  (log/trace (str "candidate-parents: spec: " (strip-refs spec)))
+  (filter #(not (fail? %))
+          (mapfn (fn [rule]
+                   (if (and (not (fail? (unifyc (get-in rule [:synsem :cat] :top)
+                                                (get-in spec [:synsem :cat] :top))))
+                            (not (fail? (unifyc (get-in rule [:synsem :infl] :top)
+                                                (get-in spec [:synsem :infl] :top))))
+                            (not (fail? (unifyc (get-in rule [:synsem :sem :tense] :top)
+                                                (get-in spec [:synsem :sem :tense] :top))))
+                            (not (fail? (unifyc (get-in rule [:synsem :modified] :top)
+                                                (get-in spec [:synsem :modified] :top)))))
+                     (unifyc spec rule)
+                     :fail))
+                 rules)))
+
+(declare morph-with-recovery)
+
+(defn lazy-shuffle [seq]
+  (lazy-seq (shuffle seq)))

 (defn exception [error-string]
   #?(:clj
@@ -266,101 +318,12 @@
                  result)]
     result))

-(defn add-complement [bolt path spec grammar lexicon index morph depth total-depth
-                      & {:keys [max-total-depth]
-                         :or {max-total-depth max-total-depth}}]
-  (log/debug (str "add-complement: start: " (show-bolt bolt path morph) "@" path))
-  (let [input-spec spec
-        from-bolt bolt ;; so we can show what (add-complement) did to the input bolt, for logging.
-        spec (unifyc spec (get-in bolt path))
-        immediate-parent (get-in bolt (butlast path))
-        complement-candidate-lexemes
-        (if (not (= true
-                    (get-in bolt (concat path [:phrasal]))))
-          (let [indexed (if index
-                         (get-lex immediate-parent :comp index spec))]
-            (if indexed indexed
-                (flatten (vals lexicon)))))
-
-        complement-pre-check (fn [child parent path-to-child]
-                               (let [child-in-bolt (get-in bolt path-to-child)]
-                                 (not (fail?
-                                       (unifyc (get-in child [:synsem] :top)
-                                               (get-in child-in-bolt [:synsem] :top))))))
-
-        filtered-lexical-complements (filter (fn [lexeme]
-                                               (complement-pre-check lexeme bolt path))
-                                             complement-candidate-lexemes)]
-    (filter #(not (fail? %))
-            (mapfn (fn [complement]
-                    (unify (copy bolt)
-                           (path-to-map path
-                                        (copy complement))))
-                  (let [debug (log/trace (str "add-complement(depth=" depth ",total-depth=" total-depth
-                                              ",path=" path ",bolt=(" (show-bolt bolt path morph)
-                                              "): calling generate-all(" (strip-refs spec) ");"
-                                              "input-spec: " input-spec))
-                        phrasal-complements (if (and (> max-total-depth total-depth)
-                                                     (= true (get-in spec [:phrasal] true)))
-                                              (generate-all spec grammar lexicon index morph (+ depth total-depth)
-                                                            :max-total-depth max-total-depth))]
-                    (if (lexemes-before-phrases total-depth)
-                      (lazy-cat (lazy-shuffle filtered-lexical-complements) phrasal-complements)
-                      (lazy-cat phrasal-complements (lazy-shuffle filtered-lexical-complements))))))))

 (defn path-to-map [path val]
   (let [feat (first path)]
     (if feat
       {feat (path-to-map (rest path) val)}
       val)))
-
-(defn in-case-of-no-phrasal-complements [bolt path run-time from-bolt complement-candidate-lexemes morph]
-  ;; No complements could be added to this bolt: Throw an exception or log/warn. debateable about which to do
-  ;; in which circumstances.
-  (let [log-limit 1000
-        log-fn (fn [message] (log/warn message))
-        throw-exception-if-no-complements-found false
-        message
-        (str " add-complement to " (get-in bolt [:rule]) " at path: " path
-             " took " run-time " msec, but found neither phrasal nor lexical complements for "
-             "'" (morph from-bolt) "'"
-             ". Bolt wants phrasal-wise: " (get-in bolt (concat path [:phrasal]))
-             ". Desired complement [:synsem] was: "
-             (strip-refs (get-in bolt (concat path [:synsem]))) ". "
-             (if (= false (get-in bolt (concat path [:phrasal]) false))
-               (str
-                (count complement-candidate-lexemes) " lexical complement(s) tried were:"
-                " "
-                (string/join "," (sort (map morph (take log-limit complement-candidate-lexemes))))
-
-                (if (< 0 (- (count complement-candidate-lexemes) log-limit))
-                  (str ",.. and "
-                       (- (count complement-candidate-lexemes) log-limit) " more."))
-
-                ";     with preds:   "
-                (string/join "," (map #(get-in % [:synsem :sem :pred]) (take log-limit complement-candidate-lexemes)))
-
-                ";     fail-paths:   "
-                (string/join ","
-                             (map #(if
-                                       (or true (not (fail? (unifyc (get-in % [:synsem :sem :pred])
-                                                                    (get-in bolt (concat path
-                                                                                [:synsem :sem :pred]))))))
-                                     (str "'" (morph %) "':"
-                                          (fail-path (strip-refs %)
-                                                     (strip-refs (get-in bolt path)))))
-                                  (take log-limit complement-candidate-lexemes)))
-
-                (if (< 0 (- (count complement-candidate-lexemes) log-limit))
-                  (str ",.. and "
-                       (- (count complement-candidate-lexemes) log-limit) " more.")))))]
-    (log-fn message)
-
-    ;; set to true to work on optimizing generation, since this situation of failing to add any
-    ;; complements is expensive.
-    (if (and throw-exception-if-no-complements-found
-             (not (= true (get-in bolt (concat path [:phrasal])))))
-      (exception message))))

 (defn lexemes-before-phrases [depth]
   "returns true or false: true means generate by adding lexemes first; otherwise, by adding phrases first. Takes depth as an argument, which makes returning true (i.e. lexemes first) increasingly likely as depth increases."


rewrite (defn get-lexemes) to be more clear hopefully

--- src/babel/generate.cljc
+++ src/babel/generate.cljc
@@ -245,16 +245,19 @@
       tree))

 (defn get-lexemes [model spec]
-  (if (= false (get-in spec [:phrasal] false))
-    (filter not-fail?
-            (map #(unify-and-log % spec model)
-                 (if-let [index-fn (:index-fn model)]
-                   (lazy-seq (index-fn spec))
-                   (do
-                     (log/warn (str "get-lexemes: no index found: using entire lexicon."))
-                     (flatten (vals
-                               (or (:lexicon (:generate model)) (:lexicon model))))))))))
-
+  "Get lexemes matching the spec. Use a model's index if available, where the index is a function that we call with _spec_ to get a set of indices. otherwise use the model's entire lexeme."
+  (->>
+
+   (if (= false (get-in spec [:phrasal] false))
+     (if-let [index-fn (:index-fn model)]
+       (lazy-seq (index-fn spec))
+       (do
+         (log/warn (str "get-lexemes: no index found: using entire lexicon."))
+         (flatten (vals
+                   (or (:lexicon (:generate model)) (:lexicon model)))))))
+
+   (map #(unify % spec))
+   (filter #(not (= :fail %)))))

 (defn lexemes-before-phrases
   "returns true or false: true means generate by adding lexemes first;


cleanup

cleanup

--- src/babel/generate.cljc
+++ src/babel/generate.cljc
@@ -32,7 +32,9 @@

 (def ^:const error-if-no-complements false)

+(declare bolts-with-comps)
 (declare candidate-parents)
+(declare comp-path-to-complements)
 (declare do-defaults)
 (declare find-comp-paths)
 (declare get-lexemes)
@@ -40,13 +42,6 @@
 (declare lexemes-before-phrases)
 (declare lightning-bolts)
 (declare not-fail?)
-
-(declare comp-path-to-complements)
-(declare create-mapping)
-
-(declare add-bolt-at)
-
-(declare bolts-with-comps)

 (defn generate-all [spec model & [depth max-depth]]
   (let [depth (or depth 0)
@@ -68,14 +63,15 @@
                                               result)))
                                         (keys bolt-and-comps)))))
                     model))
-                 (mapcat (fn [each-bolt-and-comps]
-                           (let [trellis (apply combo/cartesian-product (vals each-bolt-and-comps))]
-                             (map (fn [each-path-through-trellis]
-                                    (zipmap (keys each-bolt-and-comps)
-                                            each-path-through-trellis))
-                                  trellis)))
-                         (filter #(not (some empty? (vals %)))
-                                 (bolts-with-comps spec model depth max-depth)))))))
+                 (flatten
+                  (map (fn [each-bolt-and-comps]
+                         (let [trellis (apply combo/cartesian-product (vals each-bolt-and-comps))]
+                           (map (fn [each-path-through-trellis]
+                                  (zipmap (keys each-bolt-and-comps)
+                                          each-path-through-trellis))
+                                trellis)))
+                       (filter #(not (some empty? (vals %)))
+                               (bolts-with-comps spec model depth max-depth))))))))

 (defn generate
   "Return one (by default) or _n_ (using :take _n_) expressions matching spec _spec_ given the model _model_."
@@ -87,8 +83,6 @@
            truncate-children? true
            take-n 1}}]
   (first (generate-all spec language-model)))
-
-(declare comp-path-to-complements)

 (defn lightning-bolts
   "Returns a lazy-sequence of all possible bolts given a spec, where a bolt is a tree
@@ -186,23 +180,23 @@
   [spec model depth max-depth]
   (log/debug  (str "bolts-with-comps:" depth "/" max-depth ":" (strip-refs spec)))
   (map (fn [lb]
-         (merge
-          (let [comp-paths (find-comp-paths lb)]
-            (zipmap comp-paths
-                    (map (fn [path]
-                           (filter not-fail? (comp-path-to-complements lb path model depth max-depth)))
-                         comp-paths)))
-          {[]
+          (merge
+           (let [comp-paths (find-comp-paths lb)]
+             (zipmap comp-paths
+                     (map (fn [path]
+                            (filter not-fail? (comp-path-to-complements lb path model depth max-depth)))
+                          comp-paths)))
+           {[]
            (filter not-fail? [lb])}))
-       (let [bolts
-             (lightning-bolts model spec depth max-depth)]
-         (if (empty? bolts)
-           (do
-             (log/debug (str "bolts-with-comps:" depth "/" max-depth ":" (strip-refs spec) ": no bolts found."))
-             nil)
-           (do
-             (log/debug (str "bolts-with-comps:" depth "/" max-depth ":" (strip-refs spec) ": one or more bolts found."))
-             bolts)))))
+        (let [bolts
+              (lightning-bolts model spec depth max-depth)]
+          (if (empty? bolts)
+            (do
+              (log/debug (str "bolts-with-comps:" depth "/" max-depth ":" (strip-refs spec) ": no bolts found."))
+              nil)
+            (do
+              (log/debug (str "bolts-with-comps:" depth "/" max-depth ":" (strip-refs spec) ": one or more bolts found."))
+              bolts)))))

 ;; TODO: lightning-bolts should use this.
 (defn get-lexemes [model spec]


Helper function for event handlers

Helper function for event handlers

--- src/balance/events.cljs
+++ src/balance/events.cljs
@@ -45,6 +45,18 @@
   (fn [coeffects _]
     (assoc coeffects :ds conn)))

+;; -- Helpers ---------------------------------------------------------------
+
+(defn reg-event-ds
+  ([k interceptors handler]
+    (reg-event-fx
+      k
+      (into [] (concat [(inject-cofx :ds)] interceptors))
+      (fn [{:keys [ds]} signal]
+        { :transact (handler @ds signal) })))
+  ([k handler]
+     (reg-event-ds k [] handler)))
+
 ;; -- Handlers --------------------------------------------------------------

 (reg-event-db
@@ -52,9 +64,8 @@
  (fn [_ _]
    app-db))

-(reg-event-fx
+(reg-event-ds
   :update-task
-  default-interceptors
   (fn [_ [_ id path value]]
-    { :transact [{ :db/id id
-                   path   value }] }))
+    [[:db/add id path value]]))
+


Fix wording

Fix wording

--- src/cake/tasks/test.clj
+++ src/cake/tasks/test.clj
@@ -158,7 +158,7 @@
                                                          (merge (test-opts) (apply hash-map opts)))]
                              (report-ns ns (bake-invoke run-ns-tests ns tests))))]
                (println (ansi/style (apply str (repeat 50 " ")) :underline))
-               (println (format "\nRan %d tests across %d namespaces, containing %d assertions in %.2f seconds."
+               (println (format "\nRan %d tests in %d namespaces, containing %d assertions, in %.2f seconds."
                                 test-count
                                 ns-count
                                 assertion-count


teach key-queue about backslash

teach key-queue about backslash

--- src-cljs/frontend/components/key_queue.cljs
+++ src-cljs/frontend/components/key_queue.cljs
@@ -44,7 +44,8 @@
    221 "]"
    187 "="
    189 "-"
-   190 "."})
+   190 "."
+   220 "\\"})

 (defn event-modifiers
   "Given a keydown event, return the modifier keys that were being held."


remember scroll position when navigating overlays

--- src-cljs/frontend/controllers/controls.cljs
+++ src-cljs/frontend/controllers/controls.cljs
@@ -1335,7 +1335,15 @@

 (defmethod control-event :overlay-menu-closed
   [target message _ state]
-  (overlay/pop-overlay state))
+  (-> state
+    (overlay/pop-overlay)
+    ;; TODO: Have each new overlay pop it's scroll position
+    (dissoc :previous-scroll-position)))
+
+(defmethod post-control-event! :overlay-menu-closed
+  [target message _ previous-state current-state]
+  (when-let [scroll-position (:previous-scroll-position previous-state)]
+    (set! js/document.body.scrollTop scroll-position)))

 (defmethod control-event :roster-closed
   [target message _ state]
@@ -1899,7 +1907,12 @@
   [browser-state message {:keys [issue-id]} state]
   (-> state
     (assoc :active-issue-id issue-id)
+    (assoc :previous-scroll-position js/document.body.scrollTop)
     (handle-add-menu :issues/single-issue)))
+
+(defmethod post-control-event! :issue-expanded
+  [browser-state message {:keys [issue-id]} previous-state current-state]
+  (set! js/document.body.scrollTop 0))

 (defmethod post-control-event! :start-plan-clicked
   [browser-state message _ previous-state current-state]


CLPHN-4: recursive tree->db failing

CLPHN-4: recursive tree->db failing

--- src/cellophane/next.clj
+++ src/cellophane/next.clj
@@ -29,7 +29,7 @@
     (keyword? (nth x 0))))

 (defn recursion? [x]
-  (or (identical? '... x)
+  (or (= '... x)
       (number? x)))

 (defn- expr->key


Comment support for blake2b-128 and blake2b-256.

Due to bug in bouncy castle.

--- src/buddy/core/hash.clj
+++ src/buddy/core/hash.clj
@@ -40,8 +40,8 @@
    :sha3-256 #(SHA3Digest. 256)
    :sha3-384 #(SHA3Digest. 384)
    :sha3-512 #(SHA3Digest. 512)
-   :blake2b-128 #(Blake2bDigest. nil 16 nil nil)
-   :blake2b-256 #(Blake2bDigest. nil 32 nil nil)
+   ;; :blake2b-128 #(Blake2bDigest. nil 16 nil nil)
+   ;; :blake2b-256 #(Blake2bDigest. nil 32 nil nil)
    :blake2b-512 #(Blake2bDigest. nil 64 nil nil)
    :skein-256 #(SkeinDigest. 256 256)
    :skein-512 #(SkeinDigest. 512 512)


summarize test runs

summarize test runs

--- src/cake/tasks/test.clj
+++ src/cake/tasks/test.clj
@@ -97,10 +97,11 @@
       (when error (doall (map (partial report-error name) error))))))

 (defn report-ns [ns results]
-  (println (ansi/style (str"\ncake test " ns) :cyan :underline))
+  (print (ansi/style (apply str (repeat 40 "-")) :white))
+  (println (ansi/style (str"\ncake test " ns) :cyan))
   (doseq [test-result (doall (:tests results))]
     (report-test ns test-result))
-  (let [{:keys [fail-count pass-count error-count assertion-count test-count]}
+  (let [{:keys [fail-count pass-count error-count assertion-count test-count] :as aggregate}
         (reduce (fn [acc [name {:keys [assertions]}]]
                   (let [acc (update-in acc [:test-count] inc)]
                     (let [grouped (group-by :type assertions)
@@ -112,7 +113,7 @@
                           (update-in [:pass-count] + pass-count)
                           (update-in [:error-count] + error-count)
                           (update-in [:assertion-count] + fail-count pass-count error-count)))))
-                {:test-count 0, :assertion-count 0, :pass-count 0, :fail-count 0, :error-count 0}
+                {:ns ns, :test-count 0, :assertion-count 0, :pass-count 0, :fail-count 0, :error-count 0}
                 (:tests results))]
     (println (format "\nRan %s tests containing %s assertions."
                      test-count
@@ -123,18 +124,34 @@
                          (if (= 0 (+ fail-count
                                      error-count))
                            :green
-                           :red)))))
+                           :red)))
+    aggregate))

 (defn run-project-tests [& opts]
   (with-test-classloader
     (bake-ns (:use bake.test clojure.test
                    [clojure.string :only [join]]
                    [bake.core :only [with-context in-project-classloader?]])
-             (doseq [[ns tests] (bake-invoke get-test-vars
-                                             (flatten (for [test-path (:test-path *project*)]
-                                                        (find-namespaces-in-dir (java.io.File. test-path))))
-                                             (merge (test-opts) (apply hash-map opts)))]
-               (report-ns ns (bake-invoke run-ns-tests ns tests))))))
+             (let [{:keys [ns-count test-count assertion-count pass-count fail-count error-count]}
+                   (reduce (fn [acc {:keys [ns test-count assertion-count pass-count fail-count error-count]}]
+                             (-> acc
+                                 (update-in [:ns-count] + 1)
+                                 (update-in [:test-count] + test-count)
+                                 (update-in [:assertion-count] + assertion-count)
+                                 (update-in [:pass-count] + pass-count)
+                                 (update-in [:fail-count] + fail-count)
+                                 (update-in [:error-count] + error-count)))
+                           {:ns-count 0, :test-count 0, :assertion-count 0, :pass-count 0, :fail-count 0, :error-count 0}
+                           (for [[ns tests] (bake-invoke get-test-vars
+                                                         (flatten (for [test-path (:test-path *project*)]
+                                                                    (find-namespaces-in-dir (java.io.File. test-path))))
+                                                         (merge (test-opts) (apply hash-map opts)))]
+                             (report-ns ns (bake-invoke run-ns-tests ns tests))))]
+               (println (ansi/style (apply str (repeat 50 " ")) :underline))
+               (println (format "\nRan %d tests across %d namespaces, containing %d assertions in %d seconds."
+                                test-count ns-count assertion-count 40))
+               (println (ansi/style (format "%d OK, %d failures, %d errors." pass-count fail-count error-count)
+                                    (if (= 0 (+ fail-count error-count)) :green :red)))))))

 (deftask test #{compile-java}
   "Run project tests."


make default-* functions public

make default-* functions public

same as Om 61df81b772ed4b1180142accadc3df7a15716bf9

--- src/cellophane/next.clj
+++ src/cellophane/next.clj
@@ -1487,17 +1487,17 @@
              tempids (:id-key config)))
          next)))))

-(defn- default-merge-ident
+(defn default-merge-ident
   [_ tree ref props]
   (update-in tree ref merge props))

-(defn- default-merge-tree
+(defn default-merge-tree
   [a b]
   (if (map? a)
     (merge a b)
     b))

-(defn- default-migrate
+(defn default-migrate
   "Given app-state-pure (the application state as an immutable value), a query,
    tempids (a hash map from tempid to stable id), and an optional id-key
    keyword, return a new application state value with the tempids replaced by


Document the with-connection-pool macro

Document the with-connection-pool macro

--- src/clj_http/client.clj
+++ src/clj_http/client.clj
@@ -255,14 +255,32 @@
   (request (merge req {:method :delete :url url})))

 (defmacro with-connection-pool
-  "Macro to execute the body using a connection manager."
+  "Macro to execute the body using a connection manager. Creates a
+  ThreadSafeClientConnectionManager to use for all requests within the body of
+  the expression. An option map is allowed to set options for the connection
+  manager.
+
+  The following options are supported:
+
+  :timeout - Time that connections are left open before automatically closing
+    default: 5
+  :threads - Maximum number of threads that will be used for connecting
+    default: 4
+  :insecure? - Boolean flag to specify allowing insecure HTTPS connections
+    default: false
+
+  If the value 'nil' is specified or the value is not set, the default value
+  will be used."
   [opts & body]
   `(let [timeout# (or (:timeout ~opts) 5)
-         thread-max# (or (:thread-max ~opts) 4)
+         threads# (or (:threads ~opts) 4)
          insecure?# (:insecure? ~opts)]
+     ;; I'm leaving the connection bindable for now because in the
+     ;; future I'm toying with the idea of managing the connection
+     ;; manager yourself and passing it into the request
      (binding [core/*connection-manager*
                (doto (core/get-reusable-conn-manager timeout# insecure?#)
-                 (.setMaxTotal thread-max#))]
+                 (.setMaxTotal threads#))]
        (try
          ~@body
          (finally


`cljs.core/*loaded-libs*` must be defonce'ed

--- src/cljs/cljs/core.cljs
+++ src/cljs/cljs/core.cljs
@@ -37,7 +37,7 @@
 (def ^:dynamic *print-length* nil)
 (def ^:dynamic *print-level* nil)

-(def ^:dynamic *loaded-libs* nil)
+(defonce ^:dynamic *loaded-libs* nil)

 (defn- pr-opts []
   {:flush-on-newline *flush-on-newline*


Fixed get and nth to return not-found value when given nil

--- src/cljs/cljs/core.cljs
+++ src/cljs/cljs/core.cljs
@@ -444,7 +444,8 @@
      (when-not (nil? coll)
        (-nth coll n)))
   ([coll n not-found]
-     (when-not (nil? coll)
+     (if (nil? coll)
+       not-found
        (-nth coll n not-found))))

 (defn get
@@ -453,7 +454,8 @@
      (when-not (nil? o)
        (-lookup o k)))
   ([o k not-found]
-     (when-not (nil? o)
+     (if (nil? o)
+       not-found
        (-lookup o k not-found))))

 (defn assoc


Calculate geo centroids.

Calculate geo centroids.

--- src/clj/c2/geo/core.clj
+++ src/clj/c2/geo/core.clj
@@ -1,7 +1,7 @@
 (ns c2.geo.core
   (:use [clojure.core.match :only [match]]
         [clojure.string :only [join]]
-        [c2.maths :only [abs]])
+        [c2.maths :only [abs add sub div mul]])
   (:require c2.geom.polygon))

 (defn geo->svg
@@ -30,9 +30,7 @@
          ;;It'd be nice to recurse to the actual branch that handles Polygon, instead of repeating...
          (join (map (fn [subpoly]
                       (join (map coords->path subpoly)))
-                    xs))
-
-         :else ""))
+                    xs))))

@@ -42,9 +40,9 @@
   (defn polygon-area [poly-coordinates]
     (let [area (fn [coordinates]
                  (abs (c2.geom.polygon/area (map projection coordinates))))]
-
+
       ;;area of exterior boundary - interior holes
-      (apply - (area (first poly-coordinates))
+      (apply - (area (first poly-coordinates))
              (map area (rest poly-coordinates)))))

   (abs (match [geo]
@@ -58,6 +56,38 @@
               (polygon-area xs)

               [{:type "MultiPolygon" :coordinates xs}]
-              (apply + (map polygon-area xs))
+              (apply + (map polygon-area xs)))))

-              :else 0)))
+
+(defn centroid [geo & {:keys [projection]
+                         :or {projection identity}}]
+
+    (defn polygon-centroid
+      "Compute polygon centroid by geometric decomposition.
+     http://en.wikipedia.org/wiki/Centroid#By_geometric_decomposition"
+      [poly-coordinates]
+      (let [areas (map (fn [coordinates]
+                         (abs (c2.geom.polygon/area (map projection coordinates))))
+                       poly-coordinates)]
+
+        ;;Return hashmap containing the area so weighted centroid can be calculated for MultiPolygons.
+        {:centroid (div (apply sub (map (fn [coordinates area]
+                                 (mul (c2.geom.polygon/centroid coordinates)
+                                    area))
+                               poly-coordinates areas))
+                        (apply - areas))
+         :area (apply + areas)}))
+
+    (match [geo]
+           [{:type "Feature" :geometry g}]
+           (centroid g)
+
+           [{:type "Polygon" :coordinates xs}]
+           (:centroid (polygon-centroid xs))
+
+           [{:type "MultiPolygon" :coordinates xs}]
+           (let [centroids (map polygon-centroid xs)]
+             (div (apply add (map (fn [{:keys [centroid area]}]
+                                    (mul centroid area))
+                                  centroids))
+                  (apply add (map :area centroids))))))


use sensible default for :max-redirects

use sensible default for :max-redirects

--- src/clj_http/client.clj
+++ src/clj_http/client.clj
@@ -96,7 +96,9 @@
 (defn wrap-redirects [client]
   (fn [{:keys [request-method follow-redirects max-redirects
                redirects-count trace-redirects url]
-        :or {redirects-count 1 trace-redirects []}
+        :or {redirects-count 1 trace-redirects []
+             ;; max-redirects default taken from Firefox
+             max-redirects 20}
         :as req}]
     (let [{:keys [status] :as resp} (client req)
           resp-r (assoc resp :trace-redirects (conj trace-redirects url))]


fns pick up hash if needed

fns pick up hash if needed

--- src/cljs/cljs/core.cljs
+++ src/cljs/cljs/core.cljs
@@ -214,6 +214,10 @@

   IHash
   (-hash [o] o))
+
+(extend-type function
+  IHash
+  (-hash [o] (goog.getUid o)))

 ;;this is primitive because & emits call to array-seq
 (defn inc


Cleanup - remove json

Cleanup - remove json

--- src/cljs/ufo/utils.cljs
+++ src/cljs/ufo/utils.cljs
@@ -12,10 +12,7 @@
   (:import
    [goog.net XhrIo]
    [goog.net.EventType]
-   [goog.events EventType]
-   [goog Uri]
-   ;; Jsonp creates a new cross domain channel that sends data to the specified host URL
-   [goog.net Jsonp]))
+   [goog.events EventType]))

 (enable-console-print!)

@@ -55,12 +52,6 @@

 ;; TODO :tbeg :tend must be inside :resp

-(def uri "http://localhost:3449/")
-
-(def base-url
-  #_"http://en.wikipedia.org/w/api.php?action=opensearch&format=json&search="
-  (str uri #_"jsonreq/search=" "users/ids="))
-
 (defn send-to-remote
   "prm is a map of remotes and the pending message to be sent"
   [{:keys [search] :as prm} callback]


Fix >> :facepalm:

Fix >> :facepalm:

--- src/cljx/cats/core.cljx
+++ src/cljx/cats/core.cljx
@@ -342,10 +342,8 @@
 (defn >>
   "Performs a Haskell-style left-associative bind,
   ignoring the values produced by the monad computations."
-  ([mv mv']
-    (bind mv (fn [_] mv')))
-  ([mv & mvs]
-     (reduce bind mv mvs)))
+  [mv mv']
+  (bind mv (fn [_] mv')))

 (defn =<<
   "Same as the two argument version of `>>=` but with the


load config from multiple files

load config from multiple files

--- src/clojento/config.clj
+++ src/clojento/config.clj
@@ -3,6 +3,8 @@
             [taoensso.timbre :as l]))

 (l/info "loading clojento.config namespace")
+
+; see https://github.com/clojure-cookbook/clojure-cookbook/blob/master/04_local-io/4-15_edn-config.asciidoc

 (defn deep-merge
   "Deep merge two maps"
@@ -11,10 +13,13 @@
     (apply merge-with deep-merge values)
     (last values)))

-    (require '[clojure.edn :as edn])
-
+;(defn load-config
+;  "Given a filename, load & return a config map"
+;  [filename]
+;  (edn/read-string (slurp filename)))

 (defn load-config
-  "Given a filename, load & return a config file"
-  [filename]
-  (edn/read-string (slurp filename)))
+  "Given filename(s), load then merge & return a config map"
+  [& filenames]
+  (reduce deep-merge (map (comp edn/read-string slurp)
+                          filenames)))


Minor code style changing.

Minor code style changing.

--- src/clojure/nanomsg.clj
+++ src/clojure/nanomsg.clj
@@ -147,8 +147,7 @@
      conn)))

 (defn terminate!
-  "Send terminate signal to all open and/or blocked
-  sockets.
+  "Send terminate signal to all open and/or blocked sockets.
   This is usefull for multithreaded apps."
   []
   (Nanomsg/terminate))
@@ -159,7 +158,8 @@
   (let [d (Device. s1 s2)]
     (.run d)))

-(defn- resolve-symbols []
+(defn- resolve-symbols
+  []
   (into {} (for [[k v] (Nanomsg/symbols)]
              [(keyword (.toLowerCase k)) v])))


osa wip

osa wip


added pixel value for the test

added pixel value for the test

--- test/forma/classify/logistic_test.clj
+++ test/forma/classify/logistic_test.clj
@@ -72,7 +72,7 @@
   string, the label, and the feature vector"
   [n]
   (let [ecoid (eco-generator n)
-        obs (map conj ecoid (map vector y) (map vec X))]
+        obs (map conj ecoid (map vector (range n)) (map vector y) (map vec X))]
     (vec (take n obs))))

 (defbufferop logistic-beta-wrap
@@ -102,13 +102,13 @@
   (fact
    (let [src (create-sample-tap 100)
          beta-gen (<- [?eco ?beta]
-                      (src ?eco ?labels ?feat-training)
+                      (src ?eco ?pixel-id ?labels ?feat-training)
                       (logistic-beta-wrap ?labels ?feat-training :> ?beta))
-         alerts-query (<- [?eco ?prob]
-                          (src ?eco ?labels ?feat-update)
+         alerts-query (<- [?eco ?pixel-id ?prob]
+                          (src ?eco ?pixel-id ?labels ?feat-update)
                           (= ?eco "eco1")
                           (beta-gen ?eco ?beta)
                           (logistic-prob ?beta ?feat-update :> ?prob)
                           (> ?prob 0.5))]
-     alerts-query => (produces [["eco1" 0.9999999999765928]
-                                ["eco1" 0.9999999999963644]]))))
+     alerts-query => (produces [["eco1" [31] 0.9999999999963644]
+                                ["eco1" [49] 0.9999999999765928]]))))


Fixing the unit tests.

Fixing the unit tests.

--- test/vignette/util/thumbnail_test.clj
+++ test/vignette/util/thumbnail_test.clj
@@ -10,7 +10,7 @@
                 :middle-dir "3"
                 :top-dir "35"
                 :wikia "lotr"
-                :mode "resize"
+                :thumbnail-mode "resize"
                 :height "100"
                 :width "100"})


Started ago-world-inc-seq.

Started ago-world-inc-seq.

--- src/rewindable/ago.cljs
+++ src/rewindable/ago.cljs
@@ -29,6 +29,7 @@
 (defn make-ago-world []
   (let [last-id (atom 0)]
     (atom {:gen-id #(swap! last-id inc)
+           :seq [0]     ; Extended when a snapshot is revived (branching).
            :bufs {}     ; Keyed by buf-id.
            :smas {}     ; Keyed by buf-id, value is state-machine array.
            :smas-new {} ; Same as :smas, but for new, not yet run goroutines.
@@ -42,6 +43,9 @@
   (-> ago-world-now
       (assoc :smas (copy-sma-map (:smas ago-world-now)))
       (assoc :smas-new (copy-sma-map (:smas-new ago-world-now)))))
+
+(defn ago-world-inc-seq [ago-world]
+  (swap! ago-world #(update-in % [:seq (dec (count (:seq @ago-world)))] inc)))

 ; --------------------------------------------------------


log-message about awaiting/gaining leadership added

--- src/clj/backtype/storm/nimbus/elections.clj
+++ src/clj/backtype/storm/nimbus/elections.clj
@@ -1,6 +1,6 @@
 (ns backtype.storm.nimbus.elections
   (:import [backtype.storm.nimbus NimbusLeaderElections])
-  (:use [backtype.storm config util]))
+  (:use [backtype.storm config util log]))

 (defn local-hostname-conf [conf]
   (if (contains? conf STORM-LOCAL-HOSTNAME)
@@ -17,7 +17,9 @@
 (defn await-leadership [conf]
   (let [leader-elections (NimbusLeaderElections.)]
     (.init leader-elections conf (local-hostname-conf conf))
+    (log-message "Nimbus awaiting for leadership")
     (.awaitLeadership leader-elections)
+    (log-message "Nimbus gained leadership")
     leader-elections))

 (defn ensureLeadership [leader-elections]


File filter

File filter

--- src/set_solver/quil.clj
+++ src/set_solver/quil.clj
@@ -71,7 +71,7 @@

 (defn load-next-image [state]
   (load-image state
-              (let [next-file (->> (:file-list state)
+              (let [next-file (->> (filter-query (:file-query state) (:file-list state))
                                    (partition-by #{(:image-file state)})
                                    (remove #{(list (:image-file state))})
                                    (last)
@@ -80,23 +80,23 @@

 (defn load-prev-image [state]
   (load-image state
-              (let [prev-file (->> (:file-list state)
+              (let [prev-file (->> (filter-query (:file-query state) (:file-list state))
                                    (take-while (complement #{(:image-file state)}) )
                                    (last))]
                 (or prev-file (last (:file-list state))))))

 (defn key-pressed [state e]
   (println e)
-  (if (:typing state)
+  (if-let [field (:typing state)]
     (case (:key-code e)
       10 (assoc state :typing false)
-      8  (update-in state [:query] #(apply str (drop-last %)))
-      47 (assoc state :query "") ;; /
+      8  (update-in state [field] #(apply str (drop-last %)))
+      47 (assoc state field "") ;; /
       27 (do (set! (.key (a/current-applet)) (char 0))
-             (reset! (:debug state) nil)
-             (assoc state :typing false :query ""))
+             (when (= :query field) (reset! (:debug state) nil))
+             (assoc state :typing false field ""))
       (if (<= 32 (:key-code e) 128)
-        (update-in state [:query] #(str % (:raw-key e)))
+        (update-in state [field] #(str % (:raw-key e)))
         state))

     ;; not typing
@@ -109,7 +109,8 @@
       :h (update-in state [:left] #(- % 15))
       :+ (update-in state [:zoom] #(* % 2))
       :- (update-in state [:zoom] #(/ % 2))
-      :/ (assoc state :typing true :query "")
+      :/ (assoc state :typing :query :query "")
+      :f (assoc state :typing :file-query :file-query "")
       :down (load-next-image state)
       :up (load-prev-image state)
       :left (update-in state [:debug-offset] dec)
@@ -135,6 +136,7 @@
             :left 0
             :top 0
             :query ""
+            :file-query ""
             :show-cards false
             :query-filter true
             :debug (atom nil)
@@ -142,6 +144,12 @@
             :debug-avail (atom [])
             :debug-selected (atom [])
             :pid (re-find #"\d+" (.getName (ManagementFactory/getRuntimeMXBean)))})))
+
+(defn filter-query [query coll]
+  (let [query (.toLowerCase query)]
+    (if (empty? query)
+      coll
+      (filter #(.contains (.toLowerCase %) query) coll))))

 (defn debug [state text f]
   (let [query (.toLowerCase (:query state))
@@ -195,7 +203,7 @@
   (q/fill 0 0 0 192)
   (q/rect 0 0 300 60)
   (q/fill 255)
-  (q/text (str (select-keys state [:left :top :zoom :query :show-cards :query-filter :debug-offset])) 15 15)
+  (q/text (str (select-keys state [:left :top :zoom :query :show-cards :query-filter :debug-offset :file-query])) 15 15)
   (q/text (str (round (q/current-frame-rate)) "/" (q/target-frame-rate)) 15 45)

   (doseq [[i line] (enumerate (deref (:debug-avail state)))
@@ -205,7 +213,7 @@
       (q/fill 255))
     (q/text line 15 (+ 60 (* i 15))))

-  (doseq [[line i] (map vector (:file-list state) (range))
+  (doseq [[i line] (enumerate (filter-query (:file-query state) (:file-list state)))
           :let [visible (= line (:image-file state))]]
     (q/fill 0 0 0 192)
     (q/rect (- width 100) (* i 15) 100 15)
@@ -233,8 +241,8 @@
                   (:left state))
                (- (* (:zoom state) (-> c :bb .tl .y))
                   (:top state))
-               (* (.width card-img) 0.25)
-               (* (.height card-img) 0.25)
+               (* (.width card-img) 0.50 (:zoom state))
+               (* (.height card-img) 0.50 (:zoom state))
                )
       (q/text (str (select-keys c [:count :fill :color :shape]))
               (- (* (:zoom state) (-> c :bb .tl .x))


heh heh

heh heh

--- src/showkr/viewing.cljs
+++ src/showkr/viewing.cljs
@@ -84,8 +84,7 @@
               (d/img {:src (photo-url photo :medium)})))
           (when comments
             (CommentList {:state (:photo/comment-state photo)
-                          :comments (map (comp (partial db/entity db) :db/id)
-                                      comments)}))))
+                          :comments comments}))))
       :onMount upd
       :onUpdate upd)))


add-handler shows error message if given handler fails

Signed-off-by: Daniel Borchmann <25857343a15bf1edafebc2912e82ecf775c585c1@mailbox.tu-dresden.de>

--- src/conexp/gui/util.clj
+++ src/conexp/gui/util.clj
@@ -17,8 +17,8 @@
 	             Graphics Graphics2D BasicStroke FlowLayout]
 	   [java.awt.event KeyEvent ActionListener MouseAdapter MouseEvent]
 	   [java.io File])
-  (:use [conexp.base :only (defvar first-non-nil)]
-	[clojure.contrib.seq :only (indexed partition-by)]
+  (:use [conexp.base :only (defvar first-non-nil with-swing-error-msg)])
+  (:use [clojure.contrib.seq :only (indexed partition-by)]
 	clojure.contrib.swing-utils))

@@ -31,7 +31,8 @@
   (.addActionListener thing
     (proxy [ActionListener] []
       (actionPerformed [evt]
-	(function frame thing)))))
+	(with-swing-error-msg frame "Error"
+	  (function frame thing))))))

 (defn get-component
   "Returns the first component in component satisfing predicate."


Replace adjacent? with a some using adjacent-tiles

--- src/tile_game/board.clj
+++ src/tile_game/board.clj
@@ -52,13 +52,10 @@
   (map (partial coords->tile board)
        (adjacent-coords board (tile->coords board tile))))

-(defn- adjacent? [board p1 p2]
-  (= 1 (coords/distance (tile->coords board p1) (tile->coords board p2))))
-
 (defn slide-tile [board tile]
   (let [empty-pos (tile->index board 0)
         pos (tile->index board tile)]
-    (if (adjacent? board 0 tile)
+    (if (some #{tile} (adjacent-tiles board 0))
       (assoc board
         empty-pos tile
         pos 0)


Correctly use on-change for detecting checkbox to remove console warning

--- src/tile_game/grid.cljs
+++ src/tile_game/grid.cljs
@@ -85,7 +85,7 @@
      [:div
       [:label "Analysis Mode"]
       [:input {:type "checkbox" :checked analysis-mode
-               :on-click #(swap! app-state update-in [:analysis-mode] not)}]
+               :on-change #(swap! app-state update-in [:analysis-mode] not)}]
       [:br]
       (when analysis-mode
         (if (solve/solved? board)


Simplify make-line-dirs

Simplify make-line-dirs

--- src/constraint/svg.cljs
+++ src/constraint/svg.cljs
@@ -1,6 +1,4 @@
-(ns constraint.svg
-  (:require
-    [clojure.string :as string]))
+(ns constraint.svg)

 (defn make-triangle-marker [id arrow]
@@ -33,10 +31,12 @@

-(defn make-line-dirs [from to]
-  (let [middle (map (comp #(/ % 2) +) from to)
-        coords (map (partial string/join ",") [from middle to])]
-    (string/join " " (map str ["M" "L" "L"] coords))))
+(defn make-line-dirs [[xfrom yfrom] [xto yto]]
+  (let [xmiddle (/ (+ xfrom xto) 2)
+        ymiddle (/ (+ yfrom yto) 2)]
+    (str "M" xfrom   "," yfrom    " "
+         "L" xto     "," yto      " "
+         "L" xmiddle "," ymiddle  " ")))


fix middleware not being applied correctly

--- src/wb_es/web/index.clj
+++ src/wb_es/web/index.clj
@@ -26,6 +26,13 @@
   (GET "/random" [q & options]
        (response (web-core/random options))))

+(defroutes integration-routes
+  (wrap-routes search-route web-integration/wrap-search)
+  (wrap-routes autocomplete-route web-integration/wrap-autocomplete)
+  (wrap-routes search-exact-route web-integration/wrap-search-exact)
+  (wrap-routes count-route web-integration/wrap-count)
+  (wrap-routes random-route web-integration/wrap-random))
+
 (defroutes app
   search-route
   autocomplete-route
@@ -33,11 +40,7 @@
   count-route
   random-route
   (context "/integration" []
-           (web-integration/wrap-search search-route)
-           (web-integration/wrap-autocomplete autocomplete-route)
-           (web-integration/wrap-search-exact search-exact-route)
-           (web-integration/wrap-count count-route)
-           (web-integration/wrap-random random-route))
+           integration-routes)
   (route/not-found (response {:message "endpoint not found"})))

 (defn handler [request]


Use feature/enabled? instead of ld/feature-on?

--- src-cljs/frontend/components/header.cljs
+++ src-cljs/frontend/components/header.cljs
@@ -16,7 +16,6 @@
             [frontend.state :as state]
             [frontend.utils :as utils]
             [frontend.utils.github :refer [auth-url]]
-            [frontend.utils.launchdarkly :as ld]
             [frontend.utils.vcs-url :as vcs-url]
             [goog.string :refer [format capitalize]]
             [om.core :as om :include-macros true])
@@ -132,10 +131,10 @@
                           "/signup/")}
                  "Sign up"])]
              [:div.navbar-container {:class hamburger-state}
-              (if (and (:current-build-data app) (ld/feature-on? "show-demo-label"))
+              (if (and (:current-build-data app) (feature/enabled? "show-demo-label"))
                 [:ul.nav.navbar-nav
-                    [:li [:span.demo-label "You are viewing the CircleCI open source dashboard"
-                          (when first-build (format " with builds from %s's %s repo" (capitalize (:username first-build)) (capitalize (:reponame first-build))))]]]
+                    [:li [:span.demo-label " "
+                          (when first-build (format "You are viewing the CircleCI open source dashboard with builds from %s's %s repo" (capitalize (:username first-build)) (capitalize (:reponame first-build))))]]]
                 [:ul.nav.navbar-nav
                  (when (config/show-marketing-pages?)
                    (list


Fix the test

Fix the test

--- test/circle/backend/build/test_email.clj
+++ test/circle/backend/build/test_email.clj
@@ -11,4 +11,4 @@
 (fact "notify email works"
   (let [build (circle.backend.build.config/build-from-url (-> test/test-project :vcs_url))]
     (build/successful? (run-build build)) => truthy
-    (circle.backend.build.email/notify-build-results* build) => truthy))+    (circle.backend.build.email/send-email-build-notification build) => truthy))


remove unneeded (remove nil?)s

remove unneeded (remove nil?)s

--- src/babel/italiano/morphology/verbs.cljc
+++ src/babel/italiano/morphology/verbs.cljc
@@ -41,7 +41,7 @@
                                 (:g %))
                              patterns-conditional))
         infinitive (get-in word [:italiano])]
-    (first (remove nil? (do-replace-on infinitive unifying-patterns)))))
+    (first (do-replace-on infinitive unifying-patterns))))

 ;; </conditional>

@@ -66,7 +66,7 @@
                                 (:g %))
                              patterns-future))
         infinitive (get-in word [:italiano])]
-    (first (remove nil? (do-replace-on infinitive unifying-patterns)))))
+    (first (do-replace-on infinitive unifying-patterns))))
 ;; </future>

 ;; <imperfect>
@@ -91,7 +91,7 @@
                                 (:g %))
                              patterns-imperfect))
         infinitive (get-in word [:italiano])]
-    (first (remove nil? (do-replace-on infinitive unifying-patterns)))))
+    (first (do-replace-on infinitive unifying-patterns))))
 ;; </imperfect>

 ;; <present>


add amex tests

add amex tests

--- test/credit_card_validator/core_test.clj
+++ test/credit_card_validator/core_test.clj
@@ -34,4 +34,15 @@
       (let [card "5188360002354029"
             result (core/card-from-number card)]
         (is (= "mastercard"
+               (:type result))))))
+  (testing "amex"
+    (testing "starts with 34"
+      (let [card "3488360002354029"
+            result (core/card-from-number card)]
+        (is (= "amex"
+               (:type result)))))
+    (testing "starts with 37"
+      (let [card "3788360002354029"
+            result (core/card-from-number card)]
+        (is (= "amex"
                (:type result)))))))


(PDB-1363) Revert "(maint) applied-migrations: don't ignore exceptions"

We can't assume that we'll have access to the public schema.

This reverts commit 53210f67eb8b2223cfb719ae484313b8cec55042.

--- src/com/puppetlabs/puppetdb/scf/migrate.clj
+++ src/com/puppetlabs/puppetdb/scf/migrate.clj
@@ -1025,14 +1025,12 @@
   {:post  [(sorted? %)
            (set? %)
            (apply < 0 %)]}
-  (sql/transaction
-   (if-not (some #(= (string/lower-case %) "schema_migrations")
-                 (scf-utils/sql-current-connection-table-names))
-     (sorted-set)
-     (apply sorted-set
-            (map :version
-                 (query-to-vec
-                  "SELECT version FROM schema_migrations ORDER BY version"))))))
+  (try
+    (let [query   "SELECT version FROM schema_migrations ORDER BY version"
+          results (sql/transaction (query-to-vec query))]
+      (apply sorted-set (map :version results)))
+    (catch java.sql.SQLException e
+      (sorted-set))))

 (defn pending-migrations
   "Returns a collection of pending migrations, ordered from oldest to latest."


Fix redefine warning

Fix redefine warning

--- src/clj/salava/extra/legacy/password.clj
+++ src/clj/salava/extra/legacy/password.clj
@@ -41,7 +41,7 @@
     (throw (Exception. "unsupported password format")))
   [(hash-rounds (subs input 3 4)) (subs input 4 12) (subs input 12)])

-(defn- compare [a-bytes b-bytes]
+(defn- pw-compare [a-bytes b-bytes]
   (if (not= (count a-bytes) (count b-bytes))
     (throw (Exception. "string comparison length mismatch")))
   (= 0 (reduce bit-or (map bit-xor (.getBytes a-bytes) (.getBytes b-bytes)))))
@@ -50,4 +50,4 @@
   (if (or (s/blank? we-have) (s/blank? they-sent))
     (throw (Exception. "missing input strings")))
   (let [[rounds salt our-hash] (unpack we-have)]
-    (compare our-hash (pw-hash rounds salt they-sent))))
+    (pw-compare our-hash (pw-hash rounds salt they-sent))))


Misused get-in in control-event

Misused get-in in control-event

--- src/cljs/gtfve/controllers/controls.cljs
+++ src/cljs/gtfve/controllers/controls.cljs
@@ -11,4 +11,4 @@
   (println "Unknown control"))

 (defmethod control-event :side-panel-changed [_ [key] state]
-  (om/update! (-> state :ui :panel) :tab key))
+  (om/update! (get-in state [:ui :panel]) :tab key))


Remove new item echo

Remove new item echo

--- src/cljs/pushpopchestnutreless/core.cljs
+++ src/cljs/pushpopchestnutreless/core.cljs
@@ -67,7 +67,6 @@
       (into [:ol]
        (map #(vec [:li %]) (:stack state))))])
    [:div
-    [:p (:new-item-text state)]
     [:input
      {:on-change (on-change :change-new-item-text)
       :value (:new-item-text state)}]


message comp pre-line

message comp pre-line

--- src/cljs/swarmpit/component/message.cljs
+++ src/cljs/swarmpit/component/message.cljs
@@ -11,7 +11,8 @@
   {:backgroundColor "#fff"
    :maxWidth        "100%"
    :height          "100%"
-   :lineHeight      "30px"
+   :lineHeight      "24px"
+   :whiteSpace      "pre-line"
    :minWidth        0})

 (def message-info-body-style


Removed testing code from deletion operator.

--- src/clojush/pushgp/genetic_operators.clj
+++ src/clojush/pushgp/genetic_operators.clj
@@ -64,7 +64,6 @@
    p(3) = 0.21
    p(4) = 0.05"
   [ind]
-  (println "hihihihihihi")
   (let [new-program (loop [prog (:program ind)
                            how-many (let [prob (lrand)]
                                       (cond


Changed name of regex.

Changed name of regex.

--- src/cmr/search/data/query_to_elastic.clj
+++ src/cmr/search/data/query_to_elastic.clj
@@ -33,7 +33,7 @@
   [field concept-type]
   (get-in field-mappings [concept-type field] field))

-(def query_string_reserved-characters-regex
+(def query_string-reserved-characters-regex
   "Characters reserved for elastic query_string queries. These must be escaped."
   #"([+\-\[\]!\^:\\/{}\(\)]|&&)")

@@ -134,7 +134,7 @@
     [{:keys [field query-str]} concept-type]
     (let [field (query-field->elastic-field field concept-type)]
       {:query {:query_string {:query (str/replace query-str
-                                                  query_string_reserved-characters-regex
+                                                  query_string-reserved-characters-regex
                                                   "\\\\$1")
                               :analyzer :whitespace
                               :default_field field}}}))


CMR-203: Changed query->elastic to only use score_function query with keyword queries.

--- src/cmr/search/data/query_to_elastic.clj
+++ src/cmr/search/data/query_to_elastic.clj
@@ -38,16 +38,35 @@
     [condition concept-type]
     "Converts a query model condition into the equivalent elastic search filter"))

+(defn keyword-regexp-filter
+  "Create a regexp filter for a given field and keyword"
+  [field keyword]
+  (let [regex (str ".*" keyword ".*")]
+    {:regexp {field regex}}))
+
+; (defn keywords->name-filter
+;   "Create a filter for keyword searches that checks long-name and short-name"
+;   (let [long-name-cond
+;         condition (qm/or-conds
+
+(defn keywords->elastic-filters
+  "Create filters for keyword search"
+  [keywords]
+  (into [] (when keywords
+             ())))
+
 (defn query->elastic
   "Converts a query model into an elastic search query"
   [query]
-
-  (let [{:keys [concept-type condition]} query]
-    {:filtered {:query (q/match-all)
-                :filter (condition->elastic condition concept-type)}}
-    ;; if kwyword exist, construct the function_score part of the query and merge into the final query
-    ;; otherwise return the query
-    ))
+  (let [{:keys [concept-type condition keywords]} query
+        core-query (condition->elastic condition concept-type)]
+    (if-let [keywords (:keywords query)]
+      {:function_score {:functions []
+                        :query {:filtered {:query (q/match-all)
+                                           :filter core-query}}}}
+      {:filtered {:query (q/match-all)
+                  :filter core-query}}
+      )))

 (def sort-key-field->elastic-field
   "Submaps by concept type of the sort key fields given by the user to the exact elastic sort field to use.


When contracted, show keys for maps and number of items for vectors

--- src/datadrill/core.cljs
+++ src/datadrill/core.cljs
@@ -41,8 +41,10 @@
     [:div
      [ExpandButton {:expanded? expanded? :path path}]
      [:span "["]
-     (when expanded?
-       (map-indexed (fn [i x] ^{:key i} [DataDrill {:data x :path (conj path i) :expansion expansion}]) data))
+     (if expanded?
+       (map-indexed (fn [i x] ^{:key i} [DataDrill {:data x :path (conj path i) :expansion expansion}]) data)
+       (str (count data))
+       )
      [:span "]"]]))

 (defn MapNode [{:keys [data path expansion]}]
@@ -51,8 +53,9 @@
     [:div
      [ExpandButton {:expanded? expanded? :path path}]
      [:span "{"]
-     (when expanded?
-       (map-indexed (fn [i x] ^{:key i} [KeyValNode {:data x :path path :expansion expansion}]) data))
+     (if expanded?
+       (map-indexed (fn [i x] ^{:key i} [KeyValNode {:data x :path path :expansion expansion}]) data)
+       (clojure.string/join " " (keys data)))

      [:span "}"]]))


Add quotes to keys in collapsed mode

Add quotes to keys in collapsed mode

--- src/datafrisk/core.cljs
+++ src/datafrisk/core.cljs
@@ -102,7 +102,7 @@
       [:span "{"]
       (if expanded?
         (map-indexed (fn [i x] ^{:key i} [KeyValNode {:data x :path path :expanded-paths expanded-paths :emit-fn emit-fn}]) data)
-        [:span {:style (:keywords styles)} (clojure.string/join " " (keys data))])
+        [:span {:style (:keywords styles)} (clojure.string/join " " (->> (keys data) (map pr-str)))])
       [:span "}"]]]))

 (defn DataFrisk [{:keys [data] :as all}]


better names for cogroup

better names for cogroup

--- src/datasplash/core.clj
+++ src/datasplash/core.clj
@@ -1231,7 +1231,7 @@
      (ptransform
       :cogroup
       [^GroupSpecs group-specs]
-      (let [root-name (or (:name options) "cogroup")
+      (let [root-name (or (name (:name options)) "cogroup")
             pcolls (for [[idx [pcoll f {:keys [drop-nil?] :as opts}]]
                          (map-indexed (fn [idx s] (if (instance? PCollection s)
                                                     [idx [s nil nil]] [idx s])) (:specs group-specs))]


Adapt to muon 0.3

Adapt to muon 0.3

--- src/eventstore/muon.clj
+++ src/eventstore/muon.clj
@@ -7,7 +7,7 @@
             [clojure.java.data :as j]
             [clojure.tools.logging :as log])
   (:import (io.muoncore Muon MuonStreamGenerator)
-           (io.muoncore.future MuonFuture)
+           (io.muoncore.future MuonFuture ImmediateReturnFuture)
            (io.muoncore.transport.resource MuonResourceEvent)
            (io.muoncore.extension.amqp AmqpTransportExtension)
            (io.muoncore.extension.amqp.discovery AmqpDiscovery)
@@ -41,7 +41,7 @@
           listener (reify io.muoncore.MuonService$MuonCommand
                      (^MuonFuture onCommand [_ ^MuonResourceEvent queryEvent]
                        (log/info "onCommand" (pr-str queryEvent))
-                       (f (decode-event queryEvent))))]
+                       (ImmediateReturnFuture. (f (decode-event queryEvent)))))]
       (.onCommand m "/events" Map listener))))

 (defn muon [rabbit-url]


change port to defonce

change port to defonce

--- src/http_users/core.clj
+++ src/http_users/core.clj
@@ -5,7 +5,7 @@
          '[clojure.data.json :as json]
          '[hiccup.core :as h])

-(def port 8080)
+(defonce port 8080)
 (def all-users (atom {:tero "passu" :pasi "ppaswd" :harri "wdp"}))
 (def page-count (atom 0))


Eventsource IE support (IE10 or higher only)

--- src/gin/system/ring/jetty_async_adapter.clj
+++ src/gin/system/ring/jetty_async_adapter.clj
@@ -11,6 +11,8 @@
             [com.stuartsierra.component :as component]
             [clojure.core.async :refer [go <! close!] :as async]
             [clojure.core.async.impl.protocols :as async-protocols]))
+
+(def IE_PADDING_COMMENT (str ": " (apply str (repeatedly 2056 #(long (* (rand) 10)))) "\r\n\r\n"))

 ;; Based on ring-jetty-async-adapter by Mark McGranaghan
 ;; (https://github.com/mmcgrana/ring/tree/jetty-async)
@@ -44,6 +46,13 @@
                                           (try (.complete c)
                                                (catch Exception e
                                                  nil)))))
+            ;; IE EventSource polyfill padding
+            (when (.contains (str "" (:query-string request-map)) "evs_preamble")
+              (try (doto (.getWriter response)
+                     (.write IE_PADDING_COMMENT)
+                     (.flush))
+                   (catch Exception e
+                     nil)))
             (go (try
                   (loop []
                     (if-let [chunk (<! chunks)]


Remove console clutter

Remove console clutter

--- src/kixi/hecuba/dev.clj
+++ src/kixi/hecuba/dev.clj
@@ -40,7 +40,7 @@
      (map (partial post-resource "http://localhost:8000/projects/")) ; PUT them over HTTP
      (map deref) doall ; wait for all promises to be delivered (all responses to arrive)
      #_(every? #(= (:status %) 201))  ; check each returns a status of 201
-     println)                          ; fail otherwise!
+     assert)                          ; fail otherwise!
     system)
   (stop [_ system] system))


Added ->cli coercion that mimics output of redis-cli

--- src/labs/redis/core.clj
+++ src/labs/redis/core.clj
@@ -6,7 +6,7 @@
         [clojure.pprint :only (pprint)]
         [clojure.java.io :only (resource)])
   (:require [clojure.data.json :as json])
-  (:import [labs.redis Client ClientPool Reply BulkReply StatusReply MultiBulkReply LinkedReplyFuture]))
+  (:import [labs.redis Client ClientPool Reply ErrorReply IntegerReply BulkReply StatusReply MultiBulkReply LinkedReplyFuture]))

 (set! *warn-on-reflection* true)

@@ -81,6 +81,25 @@
       MultiBulkReply (map ->>str (value r))
       Reply (->>str (value r))
       java.lang.Object (->str r))))
+
+(defn ->cli [r]
+  (println (class r))
+  (if (nil? r) "(nil)"
+    (apply str
+           (condp instance? r
+             LinkedReplyFuture (->cli @r)
+             (Class/forName "[B")  (->str r)
+
+             BulkReply (->cli @r)
+             StatusReply (->str @r)
+             ErrorReply (str "(error) " (value r))
+             MultiBulkReply (if-let [values (seq (value r))]
+                              (interpose "\n" (map #(str "(" %1 ") " (->str %2))
+                                                   (iterate inc 0)
+                                                   values))
+                              "(empty list or set)")
+             IntegerReply (str "(integer)" (value r))
+             (->str r)))))

 ;; low level redis protocol fns


we no longer create a pom-generated.xml so we no longer have to clean it

--- src/leiningen/clean.clj
+++ src/leiningen/clean.clj
@@ -16,7 +16,6 @@
   (println "Cleaning up")
   (delete-file (str (:root project) "/" (:name project) ".jar") true)
   (delete-file (str (:root project) "/" (:name project) "-standalone.jar") true)
-  (delete-file (str (:root project) "/pom-generated.xml") true)
   (doseq [d [(:compile-path project)
              (str (:root project) "/lib")]]
     (empty-directory (file d) true)))


PDOK-1025: multimethod for render-template

--- src/main/clojure/pdok/featured/mustache.clj
+++ src/main/clojure/pdok/featured/mustache.clj
@@ -13,26 +13,28 @@
          pattern (str (apply str (interpose "|" (map #(java.util.regex.Pattern/quote %) variable-list))))]
     (re-pattern pattern)))

-(defn render-template-one-feature [template feature]
-  (clojure.string/replace template (template-to-pattern template) feature))
-
 (defn resolve-as-function [function]
   (ns-resolve *ns* (symbol (str "pdok.featured.feature/as-" function))))

 (deftype MapProxy [feature]
    clojure.lang.IFn
-    	(invoke [_ k]
+      (invoke [_ k]
              (let [feature-key (keyword (clojure.string/replace k #"\{\{|\}\}" ""))]
-      				(if (= :_geometry.gml feature-key)
+              (if (= :_geometry.gml feature-key)
                   (let [render-function (str feature-key)
                         render-function (last (clojure.string/split render-function #"\."))]

                     ((resolve-as-function render-function) (:_geometry feature)))

-                 	(or (.valAt feature feature-key) "")))))
+                  (or (.valAt feature feature-key) "")))))

-(defn render-template[template features]
+(defmulti render-template (fn [template features] (if (instance? clojure.lang.IFn features) :single-feature :feature-collection)))
+
+(defmethod render-template :single-feature [template feature]
+  (clojure.string/replace template (template-to-pattern template) feature))
+
+(defmethod render-template :feature-collection [template features]
   (let [template (read-template template)]
-    (map #(render-template-one-feature template (->MapProxy %)) features)))
+    (map #(render-template template (->MapProxy %)) features)))

 ;(with-open [s (file-stream ".test-files/new-features-single-collection-100000.json")] (time (last (features-from-package-stream s))))


fix azure-app target file encoding, fn-data cache, add metadata check

--- src/main/shadow/build/targets/azure_app.clj
+++ src/main/shadow/build/targets/azure_app.clj
@@ -1,87 +1,89 @@
-(ns shadow.build.targets.azure-app
-  (:require
-    [clojure.spec.alpha :as s]
-    [clojure.java.io :as io]
-    [clojure.data.json :as json]
-    [shadow.build :as build]
-    [shadow.build.targets.shared :as shared]
-    [shadow.build.targets.node-library :as node-lib]
-    [shadow.build.config :as config]
-    [cljs.compiler :as cljs-comp]
-    [shadow.build.data :as data]
-    [shadow.build.npm :as npm]))
-
-(s/def ::fn-map
-  (s/map-of simple-keyword? shared/unquoted-qualified-symbol?))
-
-(s/def ::app-dir shared/non-empty-string?)
-
-(s/def ::target
-  (s/keys
-    :req-un
-    [::fn-map
-     ::app-dir]))
-
-(defmethod config/target-spec :azure-fn [_]
-  (s/spec ::target))
-
-(defn do-configure [state mode {:keys [fn-map app-dir] :as config}]
-  (-> state
-      (assoc ::app-dir (io/file app-dir)
-             ::fn-map fn-map)
-      (assoc-in [:compiler-options :optimizations] :advanced)
-      (assoc-in [::build/config :devtools :enabled] false)
-      (update ::build/config merge {:exports fn-map
-                                    ;; FIXME: can't have a {:cljs some.ns/fn} function when using cljs dir
-                                    :output-to (str app-dir "/cljs/shared.js")})
-      ))
-
-(defn flush-fn-file [{::keys [app-dir] :as state} fn-id entry-fn]
-  (let [fn-ns (-> entry-fn namespace symbol)
-        fn-sym (-> entry-fn name symbol)
-
-        fn-id-s
-        (name fn-id)
-
-        fn-meta
-        (get-in state [:compiler-env :cljs.analyzer/namespaces fn-ns :defs fn-sym :meta])
-
-        fn-data
-        (reduce-kv
-          (fn [m k v]
-            (if-not (and (keyword? k) (= "azure" (namespace k)))
-              m
-              (assoc m (name k) v)))
-          {}
-          fn-meta)
-
-        output-dir
-        (io/file app-dir fn-id-s)
-
-        fn-file
-        (io/file output-dir "function.json")
-
-        index-file
-        (io/file output-dir "index.js")]
-
-    (io/make-parents fn-file)
-    (when (not= fn-data (::fn-data state))
-      (spit fn-file (json/write-str fn-data)))
-
-    (spit index-file (str "module.exports = require(\"../cljs/shared.js\")." fn-id-s ";\n"))
-
-    (assoc state
-      ::fn-data fn-data)))
-
-(defn do-flush [{::keys [fn-map] :as state}]
-  (reduce-kv flush-fn-file state fn-map))
-
-(defn process
-  [{::build/keys [mode stage config] :as state}]
-  (-> state
-      (cond->
-        (= :configure stage)
-        (do-configure mode config)
-        (= :flush stage)
-        (do-flush))
-      (node-lib/process)))
+(ns shadow.build.targets.azure-app
+  (:require
+    [clojure.spec.alpha :as s]
+    [clojure.java.io :as io]
+    [clojure.data.json :as json]
+    [shadow.build :as build]
+    [shadow.build.targets.shared :as shared]
+    [shadow.build.targets.node-library :as node-lib]
+    [shadow.build.config :as config]
+    [cljs.compiler :as cljs-comp]
+    [shadow.build.data :as data]
+    [shadow.build.npm :as npm]))
+
+(s/def ::fn-map
+  (s/map-of simple-keyword? shared/unquoted-qualified-symbol?))
+
+(s/def ::app-dir shared/non-empty-string?)
+
+(s/def ::target
+  (s/keys
+    :req-un
+    [::fn-map
+     ::app-dir]))
+
+(defmethod config/target-spec :azure-fn [_]
+  (s/spec ::target))
+
+(defn do-configure [state mode {:keys [fn-map app-dir] :as config}]
+  (-> state
+      (assoc ::app-dir (io/file app-dir)
+             ::fn-data {}
+             ::fn-map fn-map)
+      (assoc-in [:compiler-options :optimizations] :advanced)
+      (assoc-in [::build/config :devtools :enabled] false)
+      (update ::build/config merge {:exports fn-map
+                                    ;; FIXME: can't have a {:cljs some.ns/fn} function when using cljs dir
+                                    :output-to (str app-dir "/cljs/shared.js")})
+      ))
+
+(defn flush-fn-file [{::keys [app-dir] :as state} fn-id azure-fn]
+  (let [fn-ns (-> azure-fn namespace symbol)
+        fn-sym (-> azure-fn name symbol)
+
+        fn-id-s
+        (name fn-id)
+
+        fn-meta
+        (get-in state [:compiler-env :cljs.analyzer/namespaces fn-ns :defs fn-sym :meta])
+
+        fn-data
+        (reduce-kv
+          (fn [m k v]
+            (if-not (and (keyword? k) (= "azure" (namespace k)))
+              m
+              (assoc m (name k) v)))
+          {}
+          fn-meta)
+
+        output-dir
+        (io/file app-dir fn-id-s)
+
+        fn-file
+        (io/file output-dir "function.json")
+
+        index-file
+        (io/file output-dir "index.js")]
+
+    (when (empty? fn-data)
+      (throw (ex-info (format "azure fn %s did not define any azure metadata" azure-fn) {:fn-id fn-id :azure-fn azure-fn})))
+
+    (io/make-parents fn-file)
+    (when (not= fn-data (get-in state [::fn-data fn-id]))
+      (spit fn-file (json/write-str fn-data))
+      (spit index-file (str "module.exports = require(\"../cljs/shared.js\")." fn-id-s ";\n")))
+
+    (assoc-in state [::fn-data fn-id] fn-data)))
+
+(defn do-flush [{::keys [fn-map] :as state}]
+  (reduce-kv flush-fn-file state fn-map))
+
+(defn process
+  [{::build/keys [mode stage config] :as state}]
+  (-> state
+      (cond->
+        (= :configure stage)
+        (do-configure mode config)
+        (= :flush stage)
+        (do-flush))
+      (node-lib/process)))


fixed println introduced spacing problem

--- src/me/panzoo/story.clj
+++ src/me/panzoo/story.clj
@@ -335,16 +335,16 @@
 ; SyntaxHighlighter in its `class` attribute; comments are run through the
 ; Markdown processor; anchors become hrefless HTML anchors; and includes wrap
 ; the result of parsing and rendering the file they point to in `section` tags.
-;
+
 (defmethod html<- :code [[_ text]]
   (when-not (string/blank? text)
-    (println (str "

")
-             (string/escape
-               text
-               {\< "<"
-                \> ">"
-                \& "&"})
-             "

")))
+    (println (str "
"
+                  (string/escape
+                    text
+                    {\< "<"
+                     \> ">"
+                     \& "&"})
+                  "
"))))

 (defmethod html<- :comment [[_ text]]
   (println (.markdownToHtml processor text link-renderer)))


Return 503 if Metabase is still initializing :flushed:

--- src/metabase/routes.clj
+++ src/metabase/routes.clj
@@ -49,7 +49,7 @@
   (context "/api" [] (fn [& args]
                        ;; if Metabase is not finished initializing, return a generic error message rather than something potentially confusing like "DB is not set up"
                        (if-not (init-status/complete?)
-                         {:status 400, :body "Metabase is still initializing. Please sit tight..."}
+                         {:status 503, :body "Metabase is still initializing. Please sit tight..."}
                          (apply api/routes args))))
   ;; ^/app/ -> static files under frontend_client/app
   (context "/app" []


made unloaded-ns-from-ex recursive to drill down into the real cause

--- src/datasplash/core.clj
+++ src/datasplash/core.clj
@@ -33,13 +33,19 @@

 (defn unloaded-ns-from-ex
   [e]
-  (let [{:keys [class message trace-elems]} (st/parse-exception e)]
-    (when (re-find #"clojure\.lang\.Var\$Unbound|call unbound fn" message)
-      (let [[_ missing-ns] (re-find #"call unbound fn: #'([^/]+)/" message)]
-        (->> trace-elems
-             (filter #(:clojure %))
-             (map :ns)
-             (concat (list missing-ns))
+  (let [parsed (st/parse-exception e)]
+    (loop [todo parsed
+           nss (list)]
+      (if-let [{:keys [message trace-elems cause] :as current-ex} todo]
+        (if (re-find #"clojure\.lang\.Var\$Unbound|call unbound fn" message)
+          (let [[_ missing-ns] (re-find #"call unbound fn: #'([^/]+)/" message)
+                ns-to-add (->> trace-elems
+                               (filter #(:clojure %))
+                               (map :ns)
+                               (concat (list missing-ns)))]
+            (recur cause (concat ns-to-add nss)))
+          (recur cause nss))
+        (->> nss
              (remove nil?)
              (distinct)
              (map symbol))))))


require dato port in config

require dato port in config

--- src/dato/lib/server.clj
+++ src/dato/lib/server.clj
@@ -328,7 +328,7 @@
 (defn new-session-id []
   (str (UUID/randomUUID)))

-(defrecord DatoServer [routing-table datomic-uri]  )
+(defrecord DatoServer [routing-table datomic-uri])

 (defn ?assign-id [handler dato-server]
   (fn [request]
@@ -340,8 +340,13 @@
                                  (assoc-in [:session :live :dato] dato-server)))]
       response)))

+(defn validate-config [config]
+  (assert (:server config) "config must have a server field")
+  (assert (:port config) "config must have a port field"))
+
 (defn start! [handler config]
   (def -config config)
+  (validate-config config)
   (let [dato-server (:server config)]
     (def iw-handler
       (iw/run
@@ -352,6 +357,7 @@
             (?assign-id dato-server)
             (imw/wrap-session))
         {:path "/ws"
-         :host "0.0.0.0"}))
+         :host "0.0.0.0"
+         :port (:port config)}))
     (setup-tx-report-ch (dconn @dato-server))
     (def stop-tx-broadcast-ch (start-tx-broadcast! dato-server tx-report-mult))))


changed update player function

changed update player function

--- src/dodgeball/core.cljs
+++ src/dodgeball/core.cljs
@@ -45,7 +45,7 @@
        (dom/td nil))))))

 (defn update-player-position []
-    (:selected-unit (om/root-cursor app-state)))
+    (om/update! (om/ref-cursor (:selected-unit (om/root-cursor app-state))) {:x 888 :y 999}))

 (defn blank-unit [data owner]
   (reify


Remove old location fragments

Remove old location fragments

--- frontend/src/cruncher/views.cljs
+++ frontend/src/cruncher/views.cljs
@@ -247,11 +247,10 @@

 (defn validate-login-button
   "Show Login button and disable it when one of these fields is empty."
-  [email password location service]
-  (let [not-empty? (and
-                     (pos? (count email))
-                     (pos? (count password))
-                     (pos? (count service)))]
+  [email password service]
+  (let [not-empty? (and (pos? (count email))
+                        (pos? (count password))
+                        (pos? (count service)))]
     (vlib/button-primary #(auth/ajax-login email password service) not-empty? "Login")))

 (defui Login
@@ -283,7 +282,7 @@
                                                             :type        "password"
                                                             :placeholder "password"}))
                                    (google-ptc-switch this)
-                                   (validate-login-button email password location service))))))))
+                                   (validate-login-button email password service))))))))
 (def login (om/factory Login))

 (defn view-dispatcher
@@ -305,8 +304,6 @@
              (view-dispatcher this)
              (dom/div nil (vlib/back-to-top))
              (dom/hr nil)
-             (dom/div nil (status/api-test (om/props this)))
-             #_(dom/div nil (poketable (om/props this)))
-             #_(dom/div nil (login)))))
-
-
+             (dom/div nil (status/api-test (om/props this))))))
+
+


Story ID: RPC-236 wat, why was this broken?

--- test/untangled_spec/assertions_spec.cljc
+++ test/untangled_spec/assertions_spec.cljc
@@ -41,7 +41,7 @@
         (behavior "checks the exception's message matches a regex or throws"
           (assertions
             (exception-matches? (ex-info "Ph'nglui mglw'nafh Cthulhu R'lyeh wgah'nagl fhtagn" {})
-                                clojure.lang.ExceptionInfo #"(?i)chulhu")
+                                clojure.lang.ExceptionInfo #"(?i)cthulhu")
             => true
             (exception-matches? (ex-info "kthxbye" {})
                                 clojure.lang.ExceptionInfo #"cthulhu")


finish

finish

--- Add-Two-Numbers/ATN.clj
+++ Add-Two-Numbers/ATN.clj
@@ -13,3 +13,21 @@
           (recur (into [] (rest a))
                  (into [] (rest b))
                  (conj re (+ (first a) (first b)))))))
+
+(defn check-ten [l]
+  (let [f (atom 0)
+        ll (doall (for [a l]
+                    (let [inner-a (+ a @f)]
+                      (if (>= inner-a 10)
+                        (do (reset! f (int (Math/floor (/ inner-a 10))))
+                            (mod inner-a 10))
+                        inner-a
+                        ))))]
+    (if (not= 0 @f)
+      (conj (into [] ll) @f)
+      (into [] ll))))
+
+(add-two-number [2 6 8] [8 9 3 1])
+(check-ten [10 15 11 1])
+
+(check-ten (add-two-number [9 9 9 9] [9 9 9 9]))


Update params from last commit

Update params from last commit

--- src/edu/berkeley/ai/scripts/z09_aima.clj
+++ src/edu/berkeley/ai/scripts/z09_aima.clj
@@ -73,7 +73,7 @@

 (defn make-vac-experiment-set []
-  (make-aima-experiment-set "vac" 10000
+  (make-aima-experiment-set "vac" 3600
     [:product
       [:instance-num (vec (range 4))]
       [:algorithm [:bfs :dfs :idfs]]


Updated dependencies

Updated dependencies

--- project.clj
+++ project.clj
@@ -22,7 +22,7 @@
                   [org.docx4j/docx4j              "3.0.1" :exclusions [log4j org.slf4j/slf4j-log4j12]]
                 ]
   :profiles {:dev {:dependencies [
-                                   [midje          "1.6.2"]
+                                   [midje          "1.6.3"]
                                    [clj-ns-browser "1.3.1"]
                                  ]}
              :uberjar {:aot :all}}


Version 1.0.2

Version 1.0.2

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


Release version 0.7.10.

Release version 0.7.10.

--- project.clj
+++ project.clj
@@ -1,4 +1,4 @@
-(defproject org.onyxplatform/onyx-kafka "0.7.6-SNAPSHOT"
+(defproject org.onyxplatform/onyx-kafka "0.7.10"
   :description "Onyx plugin for Kafka"
   :url "https://github.com/MichaelDrogalis/onyx-kafka"
   :license {:name "Eclipse Public License"
@@ -13,7 +13,7 @@
                              :sign-releases false}}
   :dependencies [[org.clojure/clojure "1.7.0"]
                  ^{:voom {:repo "git@github.com:onyx-platform/onyx.git" :branch "master"}}
-                 [org.onyxplatform/onyx "0.7.5"]
+                 [org.onyxplatform/onyx "0.7.10"]
                  [clj-kafka "0.3.2" :exclusions [org.apache.zookeeper/zookeeper zookeeper-clj]]
                  [com.stuartsierra/component "0.2.3"]
                  [cheshire "5.5.0"]


Upgrade clojure.tools.logging to 1.1.0

Upgrade clojure.tools.logging to 1.1.0

--- project.clj
+++ project.clj
@@ -12,7 +12,7 @@
                  [thheller/shadow-cljs      "2.11.18"   :scope "provided"]
                  [reagent                   "1.0.0"]
                  [net.cgrand/macrovich      "0.2.1"]
-                 [org.clojure/tools.logging "0.4.1"]]
+                 [org.clojure/tools.logging "1.1.0"]]

   :plugins      [[day8/lein-git-inject "0.0.14"]
                  [lein-shadow          "0.3.1"]]


Adding resources directory

Adding resources directory

--- project.clj
+++ project.clj
@@ -1,5 +1,8 @@
 (defproject tttclj "0.0.1-SNAPSHOT"
   :description "Cool new project to do things and stuff"
-  :dependencies [[org.clojure/clojure "1.4.0"]]
-  :profiles {:dev {:dependencies [[midje "1.5.0"]]}})
+  :dependencies [[org.clojure/clojure "1.4.0"]
+                 [http-kit "2.1.16"]
+                 [compojure "1.1.8"]]
+  :profiles {:dev {:dependencies [[midje "1.5.0"]]}}
+  :main tttclj.web)


v2.3.2

--- project.clj
+++ project.clj
@@ -1,4 +1,4 @@
-(defproject com.wsscode/pathom "2.3.2-SNAPSHOT"
+(defproject com.wsscode/pathom "2.3.2"
   :description "A Clojure library designed to provide a collection of helper functions to support Clojure(script) graph parsers using\nom.next graph syntax."
   :url "https://github.com/wilkerlucio/pathom"
   :license {:name "MIT"


Upgrade day8/lein-git-inject to 0.0.14

Upgrade day8/lein-git-inject to 0.0.14

--- project.clj
+++ project.clj
@@ -3,7 +3,7 @@
   :url "https://github.com/day8/re-frame-template"
   :license {:name "MIT"}

-  :plugins      [[day8/lein-git-inject "0.0.11"]
+  :plugins      [[day8/lein-git-inject "0.0.14"]
                  [lein-shadow          "0.2.2"]]

   :middleware   [leiningen.git-inject/middleware]


remove references to spy-scope

remove references to spy-scope

--- project.clj
+++ project.clj
@@ -38,9 +38,8 @@
                                         :optimizations :none
                                         :pretty-print  true}}}}

-  :profiles {:dev {:dependencies [[spyscope "0.1.4"]]
+  :profiles {:dev {:dependencies []
                    :repl-options {:init-ns sally.repl}
-                   :injections [(require 'spyscope.core)]
                    :plugins [[lein-figwheel "0.1.4-SNAPSHOT"]]
                    :figwheel {:http-server-root "public"
                               :port 3449}


up version

up version

--- project.clj
+++ project.clj
@@ -1,5 +1,5 @@
-(defproject facjure/mesh "0.5.1"
-  :description "A toolkit for responsive grids and typography"
+(defproject facjure/mesh "0.6.0"
+  :description "A toolkit for responsive grids and web typography"
   :url "https://github.com/facjure/mesh"
   :license {:name "Eclipse Public License"
             :url "http://www.eclipse.org/legal/epl-v10.html"}


release 1.6.1

release 1.6.1

--- project.clj
+++ project.clj
@@ -1,4 +1,4 @@
-(defproject babel "1.6.1-SNAPSHOT"
+(defproject babel "1.6.1"
   :description "A Clojure library for generation of expressions from grammars and lexicons."
   :url "http://github.com/ekoontz/babel"
   :license {:name "Proprietary: all rights reserved. No distribution allowed without consent of owners."}


Version 2.1.2

Version 2.1.2

--- project.clj
+++ project.clj
@@ -1,4 +1,4 @@
-(defproject grafter/grafter "2.1.2-SNAPSHOT"
+(defproject grafter/grafter "2.1.2"
   :description "Tools for the hard graft of linked data processing"
   :url "http://grafter.org/"
   :license {:name "Eclipse Public License - v1.0"


Version 0.1.4-SNAPSHOT

Version 0.1.4-SNAPSHOT

--- project.clj
+++ project.clj
@@ -1,4 +1,4 @@
-(defproject com.lemondronor.leaflet-gorilla "0.1.3"
+(defproject com.lemondronor.leaflet-gorilla "0.1.4-SNAPSHOT"
   :description "A renderer for Gorilla REPL that renders geo data using Leaflet maps."
   :url "https://github.com/wiseman/leaflet-gorilla"
   :license {:name "MIT License"


Update dependencies

Update dependencies

--- project.clj
+++ project.clj
@@ -4,12 +4,12 @@
   :url "https://github.com/terop/ktra-indexer"
   :min-lein-version "2.0.0"
   :dependencies [[org.clojure/clojure "1.8.0"]
-                 [compojure "1.5.1"]
-                 [ring/ring-defaults "0.2.1"]
-                 [ring/ring-devel "1.5.0"]
-                 [org.immutant/web "2.1.5"]
+                 [compojure "1.5.2"]
+                 [ring/ring-defaults "0.2.2"]
+                 [ring/ring-devel "1.5.1"]
+                 [org.immutant/web "2.1.6"]
                  [selmer "1.10.5"]
-                 [cheshire "5.6.3"]
+                 [cheshire "5.7.0"]
                  [org.postgresql/postgresql "9.4.1212"]
                  [org.clojure/java.jdbc "0.6.1"]
                  [honeysql "0.8.2"]


Bump Java driver to 2.1.3, references #86

--- project.clj
+++ project.clj
@@ -6,8 +6,8 @@
             :url "http://www.eclipse.org/legal/epl-v10.html"}
   :dependencies [[org.clojure/clojure                          "1.6.0"]
                  [cc.qbits/hayt                                "2.0.0-rc3"]
-                 [com.datastax.cassandra/cassandra-driver-core "2.1.1"]
-                 [com.datastax.cassandra/cassandra-driver-dse  "2.1.1"]]
+                 [com.datastax.cassandra/cassandra-driver-core "2.1.3"]
+                 [com.datastax.cassandra/cassandra-driver-dse  "2.1.3"]]
   :source-paths      ["src/clojure"]
   :java-source-paths ["src/java"]
   :profiles       {:1.7 {:dependencies [[org.clojure/clojure "1.7.0-alpha4"]]}


Bump version

Bump version

--- project.clj
+++ project.clj
@@ -1,4 +1,4 @@
-(defproject org.clojure-grimoire/lib-grimoire "0.9.2"
+(defproject org.clojure-grimoire/lib-grimoire "0.9.3"
   :description "A shared library for Grimoire infrastructure"
   :url "http://github.com/clojure-grimoire/lib-grimoire"
   :license {:name "Eclipse Public License"


Remove obsolete deps from project.clj

Remove obsolete deps from project.clj

--- project.clj
+++ project.clj
@@ -1,6 +1,4 @@
 (defproject tenor "1.0.0-SNAPSHOT"
   :description "FIXME: write description"
   :dependencies [[org.clojure/clojure "1.5.1"]
-                 [overtone "0.9.1"]
-                 [clojure-nltk "2.0.3-clj-0"]
-                 [clj-wordnet "0.1.0"]])
+                 [overtone "0.9.1"]])


Update dependencies

Update dependencies

--- project.clj
+++ project.clj
@@ -5,9 +5,9 @@
   :dependencies [[org.clojure/clojure "1.10.1"]
                  [org.immutant/web "2.1.10"]
                  [compojure "1.6.2"]
-                 [ring "1.8.1"]
+                 [ring "1.8.2"]
                  [ring/ring-defaults "0.3.2"]
-                 [org.postgresql/postgresql "42.2.16"]
+                 [org.postgresql/postgresql "42.2.18"]
                  [org.clojure/java.jdbc "0.7.11"]
                  [honeysql "1.0.444"]
                  [clj-time "0.15.2"]


Use Midje 1.6

Use Midje 1.6

--- project.clj
+++ project.clj
@@ -15,14 +15,14 @@
   :repl-options {:init (do (require 'such.doc)
                            (such.doc/apis))}

-  :profiles {:dev {:dependencies [[midje "1.9.0-alpha5" :exclusions [org.clojure/clojure]]
+  :profiles {:dev {:dependencies [[midje "1.9.0-alpha6" :exclusions [org.clojure/clojure]]
                                   [org.clojure/math.combinatorics "0.1.3"]
                                   [org.clojure/data.json "0.2.6"]
                                   ;; Including compojure so that `lein ancient` will
                                   ;; tell us to upgrade, which might alert us that
                                   ;; compojure now depends on a more-modern version of
                                   ;; commons-codec.
-                                  [marick/structural-typing "2.0.4" :exclusions [marick/suchwow]]
+                                  [marick/structural-typing "2.0.5" :exclusions [marick/suchwow]]
                                   [compojure "1.5.1" :exclusions [org.clojure/clojure]]]}
              :1.7 {:dependencies [[org.clojure/clojure "1.7.0"]]}
              :1.8 {:dependencies [[org.clojure/clojure "1.8.0"]]}


Version 0.4.0

Version 0.4.0

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


bumps up version

bumps up version

--- project.clj
+++ project.clj
@@ -1,4 +1,4 @@
-(defproject thomasa/mranderson "0.2.2"
+(defproject thomasa/mranderson "0.3.0-SNAPSHOT"
   :description "Leiningen plugin to download and use some dependencies as source."
   :url "https://github.com/benedekfazekas/mranderson"
   :license {:name "Eclipse Public License"


Advance version number to 0.1.33

Advance version number to 0.1.33

--- project.clj
+++ project.clj
@@ -1,4 +1,4 @@
-(defproject io.aviso/rook "0.1.32"
+(defproject io.aviso/rook "0.1.33"
             :description "Sane, smart, fast, Clojure web services"
             :url "http://howardlewisship.com/io.aviso/documentation/rook"
             :license {:name "Apache Sofware License 2.0"


Version 2.0.62-SNAPSHOT [ci skip]

Version 2.0.62-SNAPSHOT [ci skip]

--- project.clj
+++ project.clj
@@ -1,4 +1,4 @@
-(defproject clojush "2.0.61"
+(defproject clojush "2.0.62-SNAPSHOT"
   :description "The Push programming language and the PushGP genetic programming
                 system implemented in Clojure.
                 See http://hampshire.edu/lspector/push.html"


Config for live updating and REPL in browser

--- project.clj
+++ project.clj
@@ -4,8 +4,8 @@
   :min-lein-version "2.0.0"
   :repositories [["muoncore" "http://dl.bintray.com/muoncore/muon-java"]
                  ["reactor" "http://repo.spring.io/libs-release"]]
-  :dependencies [[org.clojure/clojure "1.7.0-beta3"]
-                 [org.clojure/clojurescript "0.0-3269"]
+  :dependencies [[org.clojure/clojure "1.7.0"]
+                 [org.clojure/clojurescript "1.7.122"]
                  [io.muoncore/muon-clojure "5.2.0"]
                  [org.marianoguerra/clj-rhino "0.2.2"]
                  [compojure "1.3.4"]
@@ -45,20 +45,26 @@
                  [stylefruits/gniazdo "0.4.0"]]
   :plugins [[lein-ring "0.9.6"]
             [lein-cljsbuild "1.0.5"]
-            [lein-figwheel "0.3.3"]
+            [lein-figwheel "0.3.9"]
             [cider/cider-nrepl "0.9.1"]
             [org.clojure/tools.nrepl "0.2.10"]]
   :ring {:handler photon} ;; jetty
   :main photon.handler ;; http-kit
   :java-source-paths ["java"]
-  :figwheel {:server-port 3500
+  :figwheel {:server-port 3000
              :load-warninged-code true
+             :open-file-command "mvim"
              :ring-handler photon.handler/reloadable-app}
   :cljsbuild {:builds [{:source-paths ["src-cljs"]
                         :figwheel true
                         :compiler {:main photon.ui.frontend
                                    :asset-path "js/out"
-                                   :output-to "resources/public/js/main.js"}}]}
+                                   :output-to "resources/public/js/main.js"
+                                   :output-dir    "resources/public/js/out"
+                                   :source-map    "resources/public/js/out.js.map"
+                                   :preamble      ["react/react.min.js"]
+                                   :optimizations :none
+                                   :pretty-print  true}}]}
   :docker {:image-name "myregistry.example.org/myimage"
            :dockerfile "target/dist/Dockerfile"
            :build-dir  "target"}


Bump version of material

Bump version of material

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

   :dependencies [[org.clojure/clojure "1.8.0"]
                  [org.clojure/clojurescript "1.8.34"]
-                 [cljsjs/material "1.1.1-0"]
+                 [cljsjs/material "1.1.3-0"]
                  [com.taoensso/timbre "4.3.1"]
                  [cljsjs/clipboard "1.5.5-0"]
                  [environ "1.0.2"]


Prepare for v0.2 development

Prepare for v0.2 development

Signed-off-by: Gregory Haskins <640d9fe47775e6723f0355b7315e38f7d98d3539@gmail.com>

--- project.clj
+++ project.clj
@@ -1,4 +1,4 @@
-(defproject obcc "0.1"
+(defproject obcc "0.2-SNAPSHOT"
   :description "openblockchain compiler"
   :url "https://github.com/openblockchain/obcc"
   :license {:name "Apache License"


Version 0.1.5-SNAPSHOT

Version 0.1.5-SNAPSHOT

--- project.clj
+++ project.clj
@@ -1,4 +1,4 @@
-(defproject puppetlabs/clj-ldap "0.1.4"
+(defproject puppetlabs/clj-ldap "0.1.5-SNAPSHOT"
   :description "Clojure ldap client (Puppet Labs's fork)."
   :url "https://github.com/puppetlabs/clj-ldap"
   :dependencies [[org.clojure/clojure "1.6.0"]