Refresh versions

Refresh versions

--- .lein/profiles.clj
+++ .lein/profiles.clj
@@ -1,24 +1,20 @@
-{:user
-  {:plugins [
-    [cider/cider-nrepl "0.11.0"]
-    [lein-cljfmt "0.3.0"]
-    [lein-pprint "1.1.1"]
+{
+ :user {
+  :plugins [
+    [cider/cider-nrepl "0.12.0"]
+    [lein-cljfmt "0.5.3"]
+    [lein-pprint "1.1.2"]
     [lein-assoc "0.1.0"]
     [lein-cloverage "1.0.6"]
-    [jonase/eastwood "0.0.2"]
-    [lein-expectations "0.0.7"]
-    [lein-autoexpect "0.2.5"]
-    [com.jakemccrary/lein-test-refresh "0.13.0"]
-    [lein-ancient "0.5.5"]]
-  :repl-options {:timeout 300000}
-  :aliases {"slamhound" ["run" "-m" "slam.hound"]}
-  :dependencies [[slamhound "RELEASE"]
-                 ;[clj-stacktrace "0.2.5"]
-                 ]
-;  :injections [(let [orig (ns-resolve (doto 'clojure.stacktrace require)
-;                                       'print-cause-trace)
-;                      new (ns-resolve (doto 'clj-stacktrace.repl require)
-;                                      'pst)]
-;                 (alter-var-root orig (constantly @new)))]
-   }
- }
+    [venantius/ultra "0.4.1"]
+    [jonase/eastwood "0.2.3" :exclusions [org.clojure/clojure]]
+    [lein-expectations "0.0.8"]
+    [lein-autoexpect "1.9.0"]
+    [com.jakemccrary/lein-test-refresh "0.14.0"]
+    [lein-ancient "0.6.10"]]
+  :repl-options {
+    :timeout 300000}
+  :aliases {
+    "slamhound" ["run" "-m" "slam.hound"]}
+  :dependencies [
+    [slamhound "1.5.5"]] } }


Require backend and util instead of using them

--HG--
branch : bleeding-edge

--- src/de/kotka/vimclojure/nails.clj
+++ src/de/kotka/vimclojure/nails.clj
@@ -22,19 +22,11 @@

 (clojure.core/ns de.kotka.vimclojure.nails
   (:use
-     (de.kotka.vimclojure [util :only (with-command-line
-                                       clj->vim
-                                       safe-var-get
-                                       decide-completion-in
-                                       pretty-print
-                                       pretty-print-code
-                                       make-completion-item
-                                       resolve-and-load-namespace
-                                       stream->seq)]
-                          backend)
      [clojure.contrib.def :only (defvar)])
   (:require
-     [de.kotka.vimclojure.repl :as repl])
+     (de.kotka.vimclojure [repl :as repl]
+                          [util :as util]
+                          [backend :as backend]))
   (:import
      com.martiansoftware.nailgun.NGContext
      clojure.lang.LineNumberingPushbackReader
@@ -65,7 +57,7 @@
                            LineNumberingPushbackReader.)
                  ~'*out* (-> ~'nailContext .out OutputStreamWriter.)
                  ~'*err* (-> ~'nailContext .err PrintWriter.)]
-         (with-command-line (.getArgs ~'nailContext)
+         (util/with-command-line (.getArgs ~'nailContext)
            ~usage
            ~arguments
            ~@body)
@@ -75,9 +67,9 @@
 (defnail DocLookup
   "Usage: ng de.kotka.vimclojure.nails.DocString [options]"
   [[nspace n "Lookup the symbols in the given namespace." "user"]]
-  (let [nspace  (resolve-and-load-namespace nspace)
+  (let [nspace  (util/resolve-and-load-namespace nspace)
         symbols (map symbol (line-seq (BufferedReader. *in*)))]
-    (print (doc-lookup nspace symbols))
+    (print (backend/doc-lookup nspace symbols))
     (flush)))

 (defnail FindDoc
@@ -90,27 +82,30 @@
 (defnail JavadocPath
   "Usage: ng de.kotka.vimclojure.nails.JavadocPath [options]"
   [[nspace n "Lookup the symbols in the given namespace." "user"]]
-  (let [nspace         (resolve-and-load-namespace nspace)
+  (let [nspace         (util/resolve-and-load-namespace nspace)
         our-ns-resolve #(ns-resolve nspace %)]
-    (doseq [path (map #(-> % symbol our-ns-resolve javadoc-path-for-class)
-                      (stream->seq *in*))]
+    (doseq [path (map #(-> %
+                         symbol
+                         our-ns-resolve
+                         backend/javadoc-path-for-class)
+                      (util/stream->seq *in*))]
       (println path))))

 (defnail MetaLookup
   "Usage: ng de.kotka.vimclojure.nails.MetaLookup [options]"
   [[nspace n "Lookup the symbols in the given namespace." "user"]]
-  (let [nspace         (resolve-and-load-namespace nspace)
+  (let [nspace         (util/resolve-and-load-namespace nspace)
         our-ns-resolve #(ns-resolve nspace %)]
     (doseq [metainfo (map #(-> % symbol our-ns-resolve meta)
-                     (stream->seq *in*))]
-      (pretty-print metainfo))))
+                     (util/stream->seq *in*))]
+      (util/pretty-print metainfo))))

 (defnail DynamicHighlighting
   "Usage: ng de.kotka.vimclojure.nails.DynamicHighlighting"
   []
   (let [nspace    (read)
         c-c       (the-ns 'clojure.core)
-        the-space (resolve-and-load-namespace nspace)
+        the-space (util/resolve-and-load-namespace nspace)
         refers    (remove #(= c-c (-> % second meta :ns)) (ns-refers the-space))
         aliases   (mapcat (fn [[the-alias the-alias-space]]
                             (map #(vector (symbol (name the-alias)
@@ -128,7 +123,7 @@
         vars      (set (concat refers aliases namespaces))
         macros    (set (filter #(-> % second meta :macro) vars))
         vars      (clojure.set/difference vars macros)
-        fns       (set (filter #(let [v (safe-var-get (second %))]
+        fns       (set (filter #(let [v (util/safe-var-get (second %))]
                                   (or (fn? v)
                                       (instance? clojure.lang.MultiFn v)))
                                vars))
@@ -136,14 +131,14 @@
     (-> (hash-map "Func"     (map first fns)
                   "Macro"    (map first macros)
                   "Variable" (map first vars))
-      clj->vim
+      util/clj->vim
       println)))

 (defnail NamespaceOfFile
   "Usage: ng de.kotka.vimclojure.nails.NamespaceOfFile"
   []
   (let [of-interest '#{in-ns ns clojure.core/in-ns clojure.core/ns}
-        in-seq      (stream->seq *in*)
+        in-seq      (util/stream->seq *in*)
         candidate   (first
                       (drop-while #(or (not (instance? clojure.lang.ISeq %))
                                        (not (contains? of-interest (first %))))
@@ -159,20 +154,20 @@
 (defnail NamespaceInfo
   "Usage: ng de.kotka.vimclojure.nails.NamespaceInfo"
   []
-  (println (clj->vim (map #(-> % symbol find-ns ns-info)
-                          (line-seq (BufferedReader. *in*))))))
+  (println (util/clj->vim (map #(-> % symbol find-ns backend/ns-info)
+                               (line-seq (BufferedReader. *in*))))))

 (defnail MacroExpand
   "Usage: ng de.kotka.vimclojure.nails.MacroExpand [options]"
   [[nspace n "Lookup the symbols in the given namespace." "user"]
    [one?   o "Expand only the first macro."]]
-  (let [nspace (resolve-and-load-namespace nspace)
+  (let [nspace (util/resolve-and-load-namespace nspace)
         expand (if one
                  #(macroexpand-1 %)
                  #(macroexpand %))]
     (binding [*ns* nspace]
-      (doseq [expr (stream->seq *in*)]
-        (-> expr expand pretty-print-code)))))
+      (doseq [expr (util/stream->seq *in*)]
+        (-> expr expand util/pretty-print-code)))))

 (defnail Repl
   "Usage: ng de.kotka.vimclojure.nails.Repl [options]"
@@ -186,7 +181,7 @@
   (let [id     (Integer/parseInt id)
         line   (Integer/parseInt line)
         nspace (when (not= nspace "")
-                 (resolve-and-load-namespace nspace))]
+                 (util/resolve-and-load-namespace nspace))]
     (cond
       start (println (repl/start))
       stop  (repl/stop id)
@@ -196,7 +191,7 @@
   "Usage: ng de.kotka.vimclojure.nails.CheckSyntax"
   []
   (try
-    (dorun (stream->seq *in*))
+    (dorun (util/stream->seq *in*))
     (println true)
     (catch Exception e
       (println false))))
@@ -206,11 +201,12 @@
   [[nspace n "Start completion in this namespace." "user"]
    [prefix p "Prefix used for the match, ie. the part before /." ""]
    [base   b "Base pattern to be matched."]]
-  (let [nspace (resolve-and-load-namespace nspace)
+  (let [nspace (util/resolve-and-load-namespace nspace)
         prefix (symbol prefix)]
     (if-not (and (= base "") (= prefix ""))
-      (let [to-complete (decide-completion-in nspace prefix base)
-            completions (mapcat #(complete % nspace prefix base) to-complete)
-            completions (map #(apply make-completion-item %) completions)]
-        (println (clj->vim completions)))
+      (let [to-complete (util/decide-completion-in nspace prefix base)
+            completions (mapcat #(backend/complete % nspace prefix base)
+                                to-complete)
+            completions (map #(apply util/make-completion-item %) completions)]
+        (println (util/clj->vim completions)))
       (println "[]"))))


updating select to either-deferred monad

--- src/er_cassandra/model/select.clj
+++ src/er_cassandra/model/select.clj
@@ -1,11 +1,14 @@
 (ns er-cassandra.model.select
   (:require [manifold.deferred :as d]
+            [cats.core :as m]
+            [cats.monad.either :as either]
+            [cats.monad.deferred :as dm]
             [qbits.alia :as alia]
             [qbits.alia.manifold :as aliam]
             [qbits.hayt :as h]
             [er-cassandra.key :as k]
-            [er-cassandra.record :as r]
-            [er-cassandra.model.types])
+            [er-cassandra.record-either :as r]
+            [er-cassandra.model.types :as t])
   (:import [er_cassandra.model.types Model]))

 (defn if-primary-key-table
@@ -21,12 +24,19 @@
             t))
         (:secondary-tables model)))

+(defn if-unique-key-table
+  [^Model model key]
+  (some (fn [t]
+          (when (= (:key t) key)
+            t))
+        (:unique-key-tables model)))
+
 (defn if-lookup-key-table
   [^Model model key]
   (some (fn [t]
           (when (= (:key t) key)
             t))
-        (:lookup-tables model)))
+        (:lookup-key-tables model)))

 (defn select-from-full-table
   "one fetch - straight from a table"
@@ -40,19 +50,19 @@
    get the record from the primary table"

   [session ^Model model table record-or-key-value opts]
-  (let [lkv (k/extract-key-value (:key table) record-or-key-value opts)
-        lr-def (r/select-one session (:name table) (:key table) lkv)]
-    (d/chain lr-def
-             (fn [lr]
-               (when lr ;; ignore dangling lookups
-                 (when-let [pkv (k/extract-key-value
-                                 (get-in model [:primary-table :key])
-                                 lr)]
-                   (r/select session
-                             (get-in model [:primary-table :name])
-                             (get-in model [:primary-table :key])
-                             pkv
-                             (dissoc opts :key-value))))))))
+  (let [lkv (k/extract-key-value (:key table) record-or-key-value opts)]
+    (m/with-monad dm/either-deferred-monad
+      (m/mlet [lr (r/select-one session (:name table) (:key table) lkv)
+               pkv (m/return
+                    (when lr
+                      (t/extract-uber-key-value model lr)))]
+              (if pkv
+                (r/select session
+                          (get-in model [:primary-table :name])
+                          (get-in model [:primary-table :key])
+                          pkv
+                          (dissoc opts :key-value))
+                (m/return nil))))))

 (defn select
   "select records from primary or lookup tables as required"
@@ -71,7 +81,8 @@
                                record-or-key-value
                                opts)

-       (if-let [lookup-table (if-lookup-key-table model key)]
+       (if-let [lookup-table (or (if-unique-key-table model key)
+                                 (if-lookup-key-table model key))]

          (select-from-lookup-table session
                                    model
@@ -79,11 +90,10 @@
                                    record-or-key-value
                                    opts)

-         (let [r (d/deferred)]
-           (d/error! r
-                     (ex-info "no model table matches key"
-                              {:model model :key key}))
-           r))))))
+         (dm/with-value (either/left [:fail
+                                      {:model model
+                                       :key key}
+                                      :no-matching-key])))))))

 (defn select-one
   "select a single record, using an index table if necessary"
@@ -92,5 +102,6 @@
    (select-one session model key record-or-key-value {}))

   ([session ^Model model key record-or-key-value opts]
-   (d/chain (select session model key record-or-key-value opts)
-            first)))
+   (m/with-monad dm/either-deferred-monad
+     (m/mlet [records (select session model key record-or-key-value opts)]
+             (m/return (first records))))))


permit client to use non-vector key

permit client to use non-vector key

--- src/er_cassandra/model/select.clj
+++ src/er_cassandra/model/select.clj
@@ -61,29 +61,29 @@
    (select session model key record-or-key-value {}))

   ([session model key record-or-key-value opts]
+   (let [key (k/make-sequential key)]
+     (if-let [table (or (if-primary-key-table model key)
+                        (if-secondary-key-table model key))]

-   (if-let [table (or (if-primary-key-table model key)
-                      (if-secondary-key-table model key))]
+       (select-from-full-table session
+                               model
+                               table
+                               record-or-key-value
+                               opts)

-     (select-from-full-table session
-                             model
-                             table
-                             record-or-key-value
-                             opts)
+       (if-let [lookup-table (if-lookup-key-table model key)]

-     (if-let [lookup-table (if-lookup-key-table model key)]
+         (select-from-lookup-table session
+                                   model
+                                   lookup-table
+                                   record-or-key-value
+                                   opts)

-       (select-from-lookup-table session
-                                 model
-                                 lookup-table
-                                 record-or-key-value
-                                 opts)
-
-       (let [r (d/deferred)]
-         (d/error! r
-                   (ex-info "no model table matches key"
-                            {:model model :key key}))
-         r)))))
+         (let [r (d/deferred)]
+           (d/error! r
+                     (ex-info "no model table matches key"
+                              {:model model :key key}))
+           r))))))

 (defn select-one
   "select a single record, using an index table if necessary"


[lein] Remove lein-drip

[lein] Remove lein-drip

--- .lein/profiles.clj
+++ .lein/profiles.clj
@@ -2,10 +2,8 @@
                   [lein-fore-prob                    "0.1.2"]
                   [lein-ancient                      "0.5.4"]
                   [jonase/eastwood                   "0.2.3"]
-                  [lein-drip                         "0.1.1-SNAPSHOT"]
                   [com.jakemccrary/lein-test-refresh "0.3.4"]
                   [lein-pprint                       "1.1.1"]
                   [cider/cider-nrepl                 "0.12.0"]
-                  [lein-drip                         "0.1.1-SNAPSHOT"]
                   [venantius/ultra                   "0.4.1"]]
         :signing {:gpg-key "E5B26621"}}}


fix for workspace permission saving (#571)

* fix for workspace permission saving

* fix for adding new workspace users

--- src/cljs/org/broadinstitute/firecloud_ui/page/workspace/summary/acl_editor.cljs
+++ src/cljs/org/broadinstitute/firecloud_ui/page/workspace/summary/acl_editor.cljs
@@ -14,96 +14,104 @@
 (def ^:private access-levels ["OWNER" "WRITER" "READER" "NO ACCESS"])

-(defn- render-acl-content [props state this]
+(defn- render-acl-content [props state component]
   [modal/OKCancelForm
    {:header
     (let [workspace-id (:workspace-id props)]
       (str "Permissions for " (:namespace workspace-id) "/" (:name workspace-id)))
     :content
-    [:div {}
-     (when (:saving? @state)
-       [comps/Blocker {:banner "Updating..."}])
-     [:span {:style {:fontSize "90%"}} "Project Owner(s)"]
-     (map-indexed
-      (fn [i acl-entry]
-        [:div {:style {:padding "0.5em"}}
-         (:email acl-entry)])
-      (filter #(= (:accessLevel %) "PROJECT_OWNER") (:acl-vec @state)))
-     [:div {:style {:padding "0.5em 0" :fontSize "90%" :marginTop "0.5em"}}
-      [:div {:style {:float "left" :width 400}} "User ID"]
-      [:div {:style {:float "right" :width 200 :marginLeft "1em"}} "Access Level"]
-      (common/clear-both)]
-     (map-indexed
-      (fn [i acl-entry]
-        [:div {}
-         [input/TextField
-          {:ref (str "acl-key" i)
-           :predicates [(input/valid-email-or-empty "User ID")]
-           :style {:float "left" :width 400 :color "black"
-                   :backgroundColor (when (:read-only? acl-entry)
-                                      (:background-light style/colors))}
-           :disabled (:read-only? acl-entry)
-           :spellCheck false
-           :value (:email acl-entry)
-           :onChange #(swap! state assoc-in [:acl-vec i :email] (.. % -target -value))}]
-         (style/create-identity-select
-          {:ref (str "acl-value" i)
-           :style {:float "right" :width 200 :height 33 :marginLeft "1em"}
-           :value (:accessLevel acl-entry)
-           :onChange #(swap! state assoc-in [:acl-vec i :accessLevel]
-                             (.. % -target -value))}
-          access-levels)
-         (common/clear-both)])
-      (filter #(not= (:accessLevel %) "PROJECT_OWNER") (:acl-vec @state)))
-     [:div {:style {:marginBottom "0.5em"}}
-      [comps/Button {:text "Add new" :icon :add
-                     :onClick #(swap! state update-in [:acl-vec]
-                                      conj {:email "" :accessLevel "READER"})}]]
-     (style/create-validation-error-message (:validation-error @state))
-     [comps/ErrorViewer {:error (:save-error @state)}]]
-    :ok-button {:text "Save" :onClick #(react/call :persist-acl this)}}])
+    (react/create-element
+     [:div {}
+      (when (:saving? @state)
+        [comps/Blocker {:banner "Updating..."}])
+      [:span {:style {:fontSize "90%"}} "Project Owner(s)"]
+      (map-indexed
+       (fn [i acl-entry]
+         [:div {:style {:padding "0.5em"}}
+          (:email acl-entry)])
+       (:project-owner-acl-vec @state))
+      [:div {:style {:padding "0.5em 0" :fontSize "90%" :marginTop "0.5em"}}
+       [:div {:style {:float "left" :width 400}} "User ID"]
+       [:div {:style {:float "right" :width 200 :marginLeft "1em"}} "Access Level"]
+       (common/clear-both)]
+      (map-indexed
+       (fn [i acl-entry]
+         [:div {}
+          [input/TextField
+           {:ref (str "acl-key" i)
+            :predicates [(input/valid-email-or-empty "User ID")]
+            :style {:float "left" :width 400 :color "black"
+                    :backgroundColor (when (:read-only? acl-entry)
+                                       (:background-light style/colors))}
+            :disabled (:read-only? acl-entry)
+            :spellCheck false
+            :value (:email acl-entry)
+            :onChange #(swap! state assoc-in [:non-project-owner-acl-vec i :email] (.. % -target -value))}]
+          (style/create-identity-select
+           {:ref (str "acl-value" i)
+            :style {:float "right" :width 200 :height 33 :marginLeft "1em"}
+            :value (:accessLevel acl-entry)
+            :onChange #(swap! state assoc-in [:non-project-owner-acl-vec i :accessLevel]
+                              (.. % -target -value))}
+           access-levels)
+          (common/clear-both)])
+       (:non-project-owner-acl-vec @state))
+      [:div {:style {:marginBottom "0.5em"}}
+       [comps/Button {:text "Add new" :icon :add
+                      :onClick #(swap! state update-in [:non-project-owner-acl-vec]
+                                       conj {:email "" :accessLevel "READER"})}]]
+      (style/create-validation-error-message (:validation-error @state))
+      [comps/ErrorViewer {:error (:save-error @state)}]])
+    :ok-button {:text "Save" :onClick #(react/call :persist-acl component)}}])

 (react/defc AclEditor
   {:render
    (fn [{:keys [props state this]}]
-     (if (:acl-vec @state)
+     (if (or (:non-project-owner-acl-vec @state) (:project-owner-acl-vec @state))
        (render-acl-content props state this)
        [:div {:style {:padding "2em"}}
         (if (:load-error @state)
           (style/create-server-error-message (:load-error @state))
           [comps/Spinner {:text "Loading Permissions..."}])]))
    :persist-acl
-   (fn [{:keys [props state refs]}]
+   (fn [{:keys [props state refs this]}]
      (swap! state dissoc :save-error :validation-error)
-     (let [filtered-acl (->> (:acl-vec @state)
+     (let [filtered-acl (->> (concat (:project-owner-acl-vec @state) (:non-project-owner-acl-vec @state))
                              (map #(dissoc % :read-only?))
                              (map #(update-in % [:email] clojure.string/trim))
                              (filter #(not (empty? (:email %)))))
-           fails (apply input/validate refs (map #(str "acl-key" %) (range (count (:acl-vec @state)))))]
+           fails (apply input/validate refs (map #(str "acl-key" %) (range (count (:non-project-owner-acl-vec @state)))))]
        (if fails
          (swap! state assoc :validation-error fails)
          (do
            (swap! state assoc :saving? true)
            (endpoints/call-ajax-orch
-             {:endpoint (endpoints/update-workspace-acl (:workspace-id props))
-              :headers utils/content-type=json
-              :payload filtered-acl
-              :on-done (fn [{:keys [success? get-parsed-response]}]
-                         (swap! state dissoc :saving?)
-                         (if success?
-                           (do
-                             ((:request-refresh props))
-                             (modal/pop-modal))
-                           (swap! state assoc :save-error (get-parsed-response false))))})))))
+            {:endpoint (endpoints/update-workspace-acl (:workspace-id props))
+             :headers utils/content-type=json
+             :payload filtered-acl
+             :on-done (fn [{:keys [success? get-parsed-response]}]
+                        (swap! state dissoc :saving?)
+                        (if success?
+                          (do
+                            ((:request-refresh props))
+                            (modal/pop-modal))
+                          (swap! state assoc :save-error (get-parsed-response false))))})))))
    :component-did-mount
    (fn [{:keys [props state]}]
      (endpoints/call-ajax-orch
-       {:endpoint (endpoints/get-workspace-acl (:workspace-id props))
-        :on-done
-        (fn [{:keys [success? get-parsed-response]}]
-          (if success?
-            (swap! state assoc :acl-vec
-                   (mapv (fn [[k v]]
-                           {:email k :accessLevel v :read-only? true})
-                         (get-parsed-response false)))
-            (swap! state assoc :load-error (get-parsed-response false))))}))})
+      {:endpoint (endpoints/get-workspace-acl (:workspace-id props))
+       :on-done
+       (fn [{:keys [success? get-parsed-response]}]
+         (if success?
+           (swap! state
+                  #(reduce
+                    (fn [state [k v]]
+                      (update state
+                              (if (= v "PROJECT_OWNER")
+                                :project-owner-acl-vec
+                                :non-project-owner-acl-vec)
+                              conj {:email k :accessLevel v :read-only? true}))
+                    (assoc % :project-owner-acl-vec []
+                             :non-project-owner-acl-vec [])
+                    (get-parsed-response false)))
+           (swap! state assoc :load-error (get-parsed-response false))))}))})


removing color from logging

removing color from logging

--- src/celestial/puppet_standalone.clj
+++ src/celestial/puppet_standalone.clj
@@ -57,7 +57,7 @@
    (task run-puppet
       (let [{:keys [module]} args]
         (run (str (<< "cd /tmp/~(module :name)") " && "
-          (as-root remote (<< "./scripts/run.sh ~(args-from args) --detailed-exitcodes || [ $? -eq 2 ]"))))))
+          (as-root remote (<< "./scripts/run.sh ~(args-from args) --detailed-exitcodes --color=false || [ $? -eq 2 ]"))))))

    (task cleanup-tmp
       (let [{:keys [module]} args]


Fix anonymous (dummy) function calls

Fix anonymous (dummy) function calls

--- src/cljs/cglossa/search_inputs.cljs
+++ src/cljs/cglossa/search_inputs.cljs
@@ -80,15 +80,15 @@
      [:div.row-fluid.search-input-links
       (if (= view :simple)
         [:b "Simple"]
-        [:a {:href "" :title "Simple search box" :on-click #{}} "Simple"])
+        [:a {:href "" :title "Simple search box" :on-click #()} "Simple"])
       " | "
       (if (= view :extended)
         [:b "Extended"]
-        [:a {:href "" :title "Search for grammatical categories etc." :on-click #{}} "Extended"])
+        [:a {:href "" :title "Search for grammatical categories etc." :on-click #()} "Extended"])
       " | "
       (if (= view :cqp)
         [:b "CQP"]
-        [:a {:href "" :title "CQP expressions" :on-click #{}} "CQP"])
+        [:a {:href "" :title "CQP expressions" :on-click #()} "CQP"])
       [search-button multilingual?]
       (when multilingual? [language-add-button])]


Added new ids

Added new ids

--- src/cljs/ikea_clojure_cup/core.cljs
+++ src/cljs/ikea_clojure_cup/core.cljs
@@ -16,13 +16,8 @@
    [tool/tool-view]])

 (defn current-page []
-<<<<<<< HEAD
   [:div#wrap.container
   [:div#main
-   [bootstrap/nav [bootstrap/nav-item {:title "IKEA" :href "http://www.ikea.com/au/en/"} "IKEA"]]
-=======
-  [:div
-  [:div.container
    [bootstrap/nav-bar
     [bootstrap/nav-bar-brand
      [:a {:title "IKEA" :href "/"} "IKEA"]]
@@ -32,7 +27,6 @@
       (get-in @regions/region-state [:region :name])]
      [bootstrap/button {:title "Start over" :bs-style :danger
                         :on-click tool/start-over} "Start over"]]]
->>>>>>> bfc5b57f37cc44c0aa11ef2c2249045920e435ac
    [(session/get :current-page)]]
   [:div#footer
    [:sup "© "]


Make hints visible when editor is in the glass pane

--- src/clojure/nightcode/shortcuts.clj
+++ src/clojure/nightcode/shortcuts.clj
@@ -1,5 +1,6 @@
 (ns nightcode.shortcuts
-  (:require [seesaw.core :as s]
+  (:require [nightcode.ui :as ui]
+            [seesaw.core :as s]
             [seesaw.keymap :as keymap])
   (:import [java.awt Color Component KeyboardFocusManager KeyEventDispatcher
             Toolkit]
@@ -100,6 +101,11 @@
         (doto positioner
           (.enableFixedAttachLocation true)
           (.setAttachLocation 0.5 y))
+        (when-let [container (some-> @ui/ui-root
+                                     .getGlassPane
+                                     (s/select [:JLayeredPane])
+                                     first)]
+          (.setTopLevelContainer tip container))
         (doto tip
           (.setPositioner positioner)
           (.setVisible false))))))
@@ -108,8 +114,8 @@
   "Creates hints for all widgets within given target with IDs in `mappings`."
   [target]
   (doseq [[id mapping] mappings]
-    (when-let [btn (s/select target [(keyword (str "#" (name id)))])]
-      (create-hint! btn mapping))))
+    (some-> (s/select target [(keyword (str "#" (name id)))])
+            (create-hint! mapping))))

 (defn listen-for-shortcuts!
   "Creates a global listener for shortcuts."


Add return_genome_pop, fix parenthesis error

--- src/clojush/instructions/return.clj
+++ src/clojush/instructions/return.clj
@@ -67,7 +67,13 @@
   return_char_pop
   ^{:stack-types [:environment :char]}
   (fn [state]
-    (assoc state :return (list-concat (list {:type :char :popper true})) (:return state)))))
+    (assoc state :return (list-concat (list {:type :char :popper true}) (:return state)))))
+
+(define-registered
+  return_genome_pop
+  ^{:stack-types [:environment :genome]}
+  (fn [state]
+    (assoc state :return (list-concat (list {:type :genome :popper true}) (:return state)))))

 ; Immediately copies the current tagspace to the environment on the top
 ; of the :environment stack.


don't show search placeholder if there are tags

--- cljs/sledge/core.cljs
+++ cljs/sledge/core.cljs
@@ -411,7 +411,9 @@
                                   :id "search-term"
                                   :type "text"
                                   :size "10"
-                                  :placeholder "Search artist/album/title"
+                                  :placeholder (if (seq term)
+                                                 ""
+                                                 "Search artist/album/title")
                                   :value (:string state)
                                   :onChange
                                   #(om/set-state! owner :string


Simplify xform

Simplify xform

--- src/app/ctl.cljs
+++ src/app/ctl.cljs
@@ -103,9 +103,7 @@
              ["#doRandomize" {:on-click #(dispatch-sync [:set-randomize (.. % -target -checked)])}]
              [".help" {:on-click #(dispatch-sync [:toggle-help])}]
              ["#help" {:style (display? help-visible?)} ]
-
-             ;; there has to be another way...
-             ["#help" :*> (to-hiccup (to-doc-frag (str "
" (md->html help-tpl) "
")))]))))
+             ["#help" :*> (xform ( str "
" (md->html help-tpl) "
"))]))))

 (.click (js/jQuery "#screen")
         (fn [evt]


Cleaning up ingest lifecycle test to enhance readability.

--- system-int-test/test/cmr/system_int_test/ingest/ingest_lifecycle_integration_test.clj
+++ system-int-test/test/cmr/system_int_test/ingest/ingest_lifecycle_integration_test.clj
@@ -17,6 +17,7 @@
   ([granules]
    (assert-granules-found granules {}))
   ([granules params]
+   (index/wait-until-indexed)
    (is (d/refs-match? granules (search/find-refs :granule params))
        (str "Could not find granules with " (pr-str params)))))

@@ -24,6 +25,7 @@
   ([collections]
    (assert-collections-found collections {}))
   ([collections params]
+   (index/wait-until-indexed)
    (is (d/refs-match? collections (search/find-refs :collection params)))))

 (defn assert-collections-and-granules-found
@@ -96,11 +98,14 @@
   ;; Nothing should be found yet.
   (assert-collections-and-granules-found [] [])

+  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+  ;; Inserts
+  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
   ;; Insert collections
   (let [coll1 (make-coll 1)
         coll2 (make-coll 2)
         coll3 (make-coll 3)]
-    (index/wait-until-indexed)
     ;; The collections can be found
     (assert-collections-and-granules-found [coll1 coll2 coll3] [])

@@ -109,42 +114,41 @@
           gr2 (make-gran coll1 2)
           gr3 (make-gran coll2 3)
           gr4 (make-gran coll2 4)]
-      (index/wait-until-indexed)
-      ;; The granule can be found
-      (assert-granules-found [gr1 gr2 gr3 gr4])
+      (assert-collections-and-granules-found [coll1 coll2 coll3] [gr1 gr2 gr3 gr4])
+
+      ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+      ;; Updates
+      ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

       (let [;; Update a collection
             coll2 (update-coll coll2 {:projects (dc/projects "ESI")})
             ;; Update a granule
             gr1 (update-gran coll1 gr1 {:data-granule (dg/data-granule {:day-night "DAY"})})]
-        (index/wait-until-indexed)
         ;; All items can still be found
         (assert-collections-and-granules-found [coll1 coll2 coll3] [gr1 gr2 gr3 gr4])

-        ;; Updated collections are found
+        ;; Updated collections and granule are found with specific parameters
         (assert-collections-found [coll2] {:project "ESI"})
+        (assert-granules-found [gr1] {:day-night-flag "DAY"})

-        ;; Updated granules are found
-        (assert-granules-found [gr1] {:day-night-flag "DAY"})
+        ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+        ;; Deletion and Recreation
+        ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

         ;; Delete a granule
         (ingest/delete-concept (d/item->concept gr3))
-        (index/wait-until-indexed)
         (assert-collections-and-granules-found [coll1 coll2 coll3] [gr1 gr2 gr4])

         ;; Reingest the granule
         (let [gr3 (ingest-gran coll2 gr3)]
-          (index/wait-until-indexed)
           (assert-collections-and-granules-found [coll1 coll2 coll3] [gr1 gr2 gr3 gr4])

           ;; Delete a collection
           (ingest/delete-concept (d/item->concept coll1))
-          (index/wait-until-indexed)
           ;; Verify collection delete results in collection and child collections not found
           (assert-collections-and-granules-found [coll2 coll3] [gr3 gr4])

           ;; Reingest the collection
           (let [coll1 (ingest-coll coll1)]
-            (index/wait-until-indexed)
             (assert-collections-and-granules-found [coll1 coll2 coll3] [gr3 gr4])))))))


tree traversal (wip)

tree traversal (wip)

--- src/dev/core.clj
+++ src/dev/core.clj
@@ -4,33 +4,36 @@
             [pacl.protocols :as p]
             [clojure.walk :as walk] :reload-all))

-(def fil-cl (rdr/get-ast (io/resource "class.php")))
+(declare walk-tree)

 (defmulti processtreepart
   (fn [el]
     (if (coll? el)
-      (first el)
-      el )
+      (first el))))
+
+
+(defn tree-assembler [current-tree element]
+  (let [processed (processtreepart element)
+        tree (if (nil? processed) current-tree (conj current-tree processed))]
+    (fn [] (walk-tree element tree tree-assembler))
     ))

-(defn tree-assembler [element]
-  (processtreepart element)
-  (fn [] (walk-tree element tree-assembler)))
+(defn walk-tree
+  ([top processor-fn]
+   (walk-tree top [] processor-fn))
+  ([top tree processor-fn]
+   (let [ only-colls (filter coll? top)  ]
+     (if (empty? only-colls)
+       tree
+       (map (fn [element]
+              (trampoline (fn [el] (processor-fn tree el)) element))
+            only-colls)))))

-
-(defn walk-tree [tree processor-fn]
-  (map (fn [element]
-         (trampoline
-          (fn [el]
-            (when (coll? el)
-              (processor-fn el))) element))
-       tree))
-
-(defmethod processtreepart :class_declaration_statement [el] (println "class declaration" el) )
-(defmethod processtreepart :class_statement [el] (println "class statement" :statement))
-(defmethod processtreepart :method_modifiers [el] (println "methodmodifiers") )
-(defmethod processtreepart :property_list [el] (println "property_list" (second el)))
-(defmethod processtreepart :variable_modifiers [el] (println "variable modifiers") )
-(defmethod processtreepart :property [el] (println "property" el))
+(defmethod processtreepart :class_declaration_statement [el]  (nth el 2))
+(defmethod processtreepart :class_statement [el]  :statement)
+(defmethod processtreepart :method_modifiers [el]  :method_modifiers)
+(defmethod processtreepart :property_list [el]  :property_list)
+(defmethod processtreepart :variable_modifiers [el]  :variable_modifiers)
+(defmethod processtreepart :property [el]  :property)
 (defmethod processtreepart :default [el])


make service functions private (#306)

make service functions private (#306)

--- src/etaoin/api.clj
+++ src/etaoin/api.clj
@@ -2866,7 +2866,7 @@
   (format "http://%s:%s" host port))

-(defn create-driver
+(defn- -create-driver
   "Creates a new driver instance.

   Returns an atom that represents driver's state. Some functions, for
@@ -2921,7 +2921,7 @@
       ssl  (assoc :ssl ssl))))

-(defn run-driver
+(defn- -run-driver
   "Runs a driver process locally.

   Creates a UNIX process with a Webdriver HTTP server. Host and port
@@ -2930,7 +2930,7 @@

   Arguments:

-  - `driver` is an atom created with `create-driver` function.
+  - `driver` is an atom created with `-create-driver` function.

   - `opt` is an optional map with the following possible parameters:

@@ -3008,7 +3008,7 @@
            :process process)
     driver))

-(defn connect-driver
+(defn- -connect-driver
   "Connects to a running Webdriver server.

   Creates a new session on Webdriver HTTP server. Sets the session to
@@ -3130,15 +3130,15 @@

   - `type` a keyword determines a driver type.

-  - `opt` a map of all possible parameters that `create-driver`,
-  `run-driver` and `connect-driver` may accept."
+  - `opt` a map of all possible parameters that `-create-driver`,
+  `-run-driver` and `-connect-driver` may accept."
   ([type]
    (boot-driver type {}))
   ([type {:keys [host] :as opt}]
    (cond-> type
-     true       (create-driver opt)
-     (not host) (run-driver opt)
-     true       (connect-driver opt))))
+     true       (-create-driver opt)
+     (not host) (-run-driver opt)
+     true       (-connect-driver opt))))

 (defn quit
   "Closes the current session and stops the driver."


Don't use iterator as it prevents multi-threading

--- resources/isometric-rpg/utils.clj
+++ resources/isometric-rpg/utils.clj
@@ -33,9 +33,11 @@
   [screen entity layer-name]
   (let [entity (screen->isometric screen entity)
         rect (entity-rect entity 0)
-        layer (map-layer screen layer-name)]
-    (->> (for [o (map-objects layer)]
-           (let [r (map-object! o :get-rectangle)
+        layer (map-layer screen layer-name)
+        objects (map-objects layer)]
+    (->> (for [n (range (map-objects! objects :get-count))]
+           (let [o (map-objects! objects :get n)
+                 r (map-object! o :get-rectangle)
                  x (/ (rectangle! r :get-x) (/ pixels-per-tile 2))
                  y (/ (rectangle! r :get-y) (/ pixels-per-tile 2))
                  width (/ (rectangle! r :get-width) (/ pixels-per-tile 2))


use consitent case for args docs

use consitent case for args docs

--- src/io/perun.clj
+++ src/io/perun.clj
@@ -86,7 +86,7 @@
    The global metadata will be attached to fileset where it can be
    read and manipulated by the tasks. Render tasks will pass this
    as the first argument to render functions."
-  [n filename NAME str "filename where to read global metadata"]
+  [n filename NAME str "filename to read global metadata from"]
   (boot/with-pre-wrap fileset
     (perun/set-global-meta
       fileset
@@ -119,8 +119,8 @@

 (deftask gravatar
   "Find gravatar urls using emails"
-  [s source-key SOURCE-PROP kw "Email property used to lookup gravatar url"
-   t target-key TARGET-PROP kw "Property name to store gravatar url"]
+  [s source-key SOURCE-PROP kw "email property used to lookup gravatar url"
+   t target-key TARGET-PROP kw "property name to store gravatar url"]
   (let [pod (create-pod ttr-deps)]
     (boot/with-pre-wrap fileset
       (let [files         (perun/get-meta fileset)
@@ -169,7 +169,7 @@

 (deftask slug
   "Adds :slug key to files metadata. Slug is derived from filename."
-  [s slug-fn SLUGFN code "Function to build slug from filename"]
+  [s slug-fn SLUGFN code "function to build slug from filename"]
   (boot/with-pre-wrap fileset
     (let [slug-fn       (or slug-fn default-slug-fn)
           files         (perun/get-meta fileset)
@@ -188,8 +188,8 @@
   "Adds :permalink key to files metadata. Value of key will determine target path.

    Make files permalinked. E.x. about.html will become about/index.html"
-  [p permalink-fn PERMALINKFN code "Function to build permalink from TmpFile metadata"
-   f filterer     FILTER   code "Filter function"]
+  [p permalink-fn PERMALINKFN code "function to build permalink from TmpFile metadata"
+   f filterer     FILTER   code "filter function"]

   (boot/with-pre-wrap fileset
     (let [options       (merge +permalink-defaults+ *opts*)
@@ -222,9 +222,9 @@

 (deftask sitemap
   "Generate sitemap"
-  [f filename FILENAME str "Generated sitemap filename"
-   o target   OUTDIR   str "The output directory"
-   u url      URL      str "Base URL"]
+  [f filename FILENAME str "generated sitemap filename"
+   o target   OUTDIR   str "the output directory"
+   u url      URL      str "base URL"]
   (let [pod     (create-pod sitemap-deps)
         tmp     (boot/tmp-dir!)
         options (merge +sitemap-defaults+ *opts*)]
@@ -243,11 +243,11 @@

 (deftask rss
   "Generate RSS feed"
-  [f filename    FILENAME    str "Generated RSS feed filename"
-   o target      OUTDIR      str "The output directory"
-   t title       TITLE       str "RSS feed title"
-   p description DESCRIPTION str "RSS feed description"
-   l link        LINK        str "RSS feed link"]
+  [f filename    FILENAME    str "generated RSS feed filename"
+   o target      OUTDIR      str "the output directory"
+   t title       TITLE       str "feed title"
+   p description DESCRIPTION str "feed description"
+   l link        LINK        str "feed link"]
   (let [pod     (create-pod rss-deps)
         tmp     (boot/tmp-dir!)
         options (merge +rss-defaults+ *opts*)]
@@ -267,12 +267,12 @@

 (deftask atom-feed
   "Generate Atom feed"
-  [f filename    FILENAME    str "Generated Atom feed filename"
-   o target      OUTDIR      str "The output directory"
-   t title       TITLE       str "Atom feed title"
-   s subtitle    SUBTITLE    str "Atom feed subtitle"
-   p description DESCRIPTION str "Atom feed description"
-   l link        LINK        str "Atom feed link"]
+  [f filename    FILENAME    str "generated Atom feed filename"
+   o target      OUTDIR      str "the output directory"
+   t title       TITLE       str "feed title"
+   s subtitle    SUBTITLE    str "feed subtitle"
+   p description DESCRIPTION str "feed description"
+   l link        LINK        str "feed link"]
   (let [pod     (create-pod atom-deps)
         tmp     (boot/tmp-dir!)
         options (merge +atom-defaults+ *opts*)]
@@ -315,9 +315,9 @@
    If permalink is set for the file, it is used as the filepath else. If permalink
    ends in slash, index.html is used as filename. If permalink is not set, the
    original filename is used with file extension set to html."
-  [o out-dir  OUTDIR   str  "The output directory"
-   f filterer FILTER   code "Filter function"
-   r renderer RENDERER sym  "Page renderer. Must be fully qualified symbol which resolves to a function."]
+  [o out-dir  OUTDIR   str  "the output directory"
+   f filterer FILTER   code "filter function"
+   r renderer RENDERER sym  "page renderer(fully qualified symbol which resolves to a function)"]
   (let [pods    (wrap-pool (pod/pod-pool (boot/get-env)))
         tmp     (boot/tmp-dir!)
         options (merge +render-defaults+ *opts*)]
@@ -348,13 +348,13 @@

 (deftask collection
   "Render collection files"
-  [o out-dir    OUTDIR     str  "The output directory"
-   r renderer   RENDERER   sym  "Page renderer. Fully qualified symbol resolving to a function."
-   f filterer   FILTER     code "Filter function"
-   s sortby     SORTBY     code "Sort by function"
-   g groupby    GROUPBY    code "Group posts by function, keys will be used as filenames where posts (values) will be rendered"
-   c comparator COMPARATOR code "Sort by comparator function"
-   p page       PAGE       str  "Collection result page path"]
+  [o out-dir    OUTDIR     str  "the output directory"
+   r renderer   RENDERER   sym  "page renderer (fully qualified symbol resolving to a function)"
+   f filterer   FILTER     code "filter function"
+   s sortby     SORTBY     code "sort by function"
+   g groupby    GROUPBY    code "group posts by function, keys will be used as filenames where posts (values) will be rendered"
+   c comparator COMPARATOR code "sort by comparator function"
+   p page       PAGE       str  "collection result page path"]
   (let [pods      (wrap-pool (pod/pod-pool (boot/get-env)))
         tmp       (boot/tmp-dir!)
         options   (merge +collection-defaults+ *opts* (if-let [p (:page *opts*)]


more comments

more comments

--- src/babel/italiano/grammar.cljc
+++ src/babel/italiano/grammar.cljc
@@ -477,4 +477,4 @@
                (:lookup medium)
                (:grammar medium)))

-(log/info "Italiano grammar defined.")
+(log/info "Italiano grammars defined (small, medium).")


fix typos in pronoun "lo"

fix typos in pronoun "lo"

--- src/babel/italiano/lexicon.cljc
+++ src/babel/italiano/lexicon.cljc
@@ -1403,7 +1403,7 @@
                     :person :3rd
                     :number :sing}
               :sem {:human true
-                    :pred :lo}
+                    :pred :lui}
               :subcat '()}}

     {:synsem {:cat :noun
@@ -1414,7 +1414,7 @@
                     :number :sing}
               :sem {:human false
                     :place false
-                    :pred :lo}
+                    :pred :lui}
               :subcat '()}
        :italiano {:initial true  ;; TODO: verify that 'lo' above and this below are being unified correctly.
                   :pronoun true


implement Awakening Center

implement Awakening Center

--- src/clj/game/cards-upgrades.clj
+++ src/clj/game/cards-upgrades.clj
@@ -22,6 +22,27 @@
                                                #(assoc % :successful-run
                                                          {:effect (effect (handle-access [ash])) :card ash}))))
                          :msg "prevent the Runner from accessing cards other than Ash 2X3ZB9CY"}}]}
+
+   "Awakening Center"
+   {:abilities [{:label "Host a piece of bioroid ICE"
+                 :cost [:click 1] :prompt "Choose a piece of bioroid ICE to host on Awakening Center"
+                 :choices (req (filter #(and (= (:type %) "ICE")
+                                             (has? % :subtype "Bioroid")) (:hand corp)))
+                 :msg "host a piece of bioroid ICE"
+                 :effect (effect (trigger-event :corp-install target)
+                                 (host card target {:facedown true}))}
+                {:req (req (and this-server (= (get-in @state [:run :position]) 0)))
+                 :label "Rez a hosted piece of bioroid ICE"
+                 :prompt "Choose a piece of bioroid ICE to rez" :choices (req (:hosted card))
+                 :msg (msg "lower the rez cost of " (:title target) " by 7 [Credits] and force the Runner to encounter it")
+                 :effect (effect (rez-cost-bonus -7) (rez target)
+                                 (update! (dissoc (get-card state target) :facedown))
+                                 (register-events {:run-ends
+                                                    {:effect (req (doseq [c (:hosted card)]
+                                                                    (when (:rezzed c)
+                                                                      (trash state side c)))
+                                                                  (unregister-events state side card))}} card))}]
+    :events {:run-ends nil}}

    "Bernice Mai"
    {:events {:successful-run {:req (req this-server)


Fix searching

Fix searching

--- src/cljc/robinson/describe.cljc
+++ src/cljc/robinson/describe.cljc
@@ -109,7 +109,7 @@
   "Describe the player's cell."
   [state]
   (let [xy (player-xy state)
-        description (apply describe-cell-at-xy state xy)]
+        description (apply describe-cell-at-xy (update-in state [:world :time] dec) xy)]
     (append-log state (format "Here %s%s" (clojure.string/lower-case (first description))
                                            (apply str (rest description))))))


Fix viewport position during start of game

--- src/cljc/robinson/worldgen.cljc
+++ src/cljc/robinson/worldgen.cljc
@@ -387,8 +387,9 @@
                                         :lava-points lava-points}}
         place-id               (apply rv/xy->place-id min-state (rc/pos->xy starting-pos))
         [sx sy]                (rc/pos->xy starting-pos)
-        [vx vy]                (rv/place-id->anchor-xy min-state (rv/xy->place-id min-state sx sy))
-        place-0                (init-island min-state vx vy width height)
+        [ax ay]                (rv/place-id->anchor-xy min-state (rv/xy->place-id min-state sx sy))
+        [vx vy]                [(int (- sx (/ width 2))) (int (- sy (/ height 2)))]
+        place-0                (init-island min-state ax ay width height)
         fruit-ids              [:red-fruit :orange-fruit :yellow-fruit :green-fruit :blue-fruit :purple-fruit :white-fruit :black-fruit]
         poisoned-fruit         (set (take (/ (count fruit-ids) 2) (rr/rnd-shuffle fruit-ids)))
         skin-identifiable      (set (take (/ (count poisoned-fruit) 2) (rr/rnd-shuffle poisoned-fruit)))


Fix starting chunk offset

Fix starting chunk offset

--- src/cljc/robinson/worldgen.cljc
+++ src/cljc/robinson/worldgen.cljc
@@ -200,7 +200,9 @@
         n                     (rn/create-noise (rr/create-random seed))
         volcano-pos           (get-in state [:world :volcano-pos])
         lava-xys              (get-in state [:world :lava-points])]
-    {:spawned-monsters {}
+    {:seed seed
+     :pos {:x x :y y}
+     :spawned-monsters {}
      :cells            (vec
                         (for [y (range y (+ y height))]
                          (vec
@@ -385,7 +387,7 @@
                                         :lava-points lava-points}}
         place-id               (apply rv/xy->place-id min-state (rc/pos->xy starting-pos))
         [sx sy]                (rc/pos->xy starting-pos)
-        [vx vy]                [(int (- sx (/ width 2))) (int (- sy (/ height 2)))]
+        [vx vy]                (rv/place-id->anchor-xy min-state (rv/xy->place-id min-state sx sy))
         place-0                (init-island min-state vx vy width height)
         fruit-ids              [:red-fruit :orange-fruit :yellow-fruit :green-fruit :blue-fruit :purple-fruit :white-fruit :black-fruit]
         poisoned-fruit         (set (take (/ (count fruit-ids) 2) (rr/rnd-shuffle fruit-ids)))


Cleaning up a bit.

Cleaning up a bit.

--- src/cljs/alert_viewer/core.cljs
+++ src/cljs/alert_viewer/core.cljs
@@ -8,7 +8,6 @@
 (enable-console-print!)

 (defonce app-state (atom {:text "Alert Viewer"
-                          :history nil
                           :stats nil
                           :alerts nil}))

@@ -56,20 +55,29 @@
 (declare build-main)

-(defcomponent alert-history-item [{{{:keys [execution_time]} :result} :_source}
-                                  _]
+(defn printable-datetime [dt]
+  (tfmt/unparse
+   (tfmt/formatter "MM/dd/YYYY hh:mm:ss a")
+   (tfmt/parse (tfmt/formatters :date-time) dt)))
+
+
+(defcomponent alert-history-item
+  [{{{:keys [execution_time]} :result} :_source} _]
   (render [_]
     (dom/tr
-     (dom/td (tfmt/unparse
-              (tfmt/formatter "MM/dd/YYYY hh:mm:ss a")
-              (tfmt/parse (tfmt/formatters :date-time)  execution_time))))))
+     (dom/td (printable-datetime execution_time)))))
+

 (defcomponent alert-detail [{:keys [history]} _]
   (render [_]
     (dom/div
      (dom/h2 {:class "subheader"} "Alert Detail")
      (dom/table
-      (om/build-all alert-history-item history))
+      (dom/thead
+       (dom/tr
+        (dom/th "Run On")))
+      (dom/tbody
+       (om/build-all alert-history-item history)))
      (dom/a {:href "#"
              :onClick #(build-main)} "Back"))))

@@ -81,8 +89,6 @@
              :onClick #(alert-history
                         key
                         (fn [r]
-                          (swap! app-state assoc :history
-                                 (get-in r [:hits :hits]))
                           (om/root alert-detail
                                    {:history (get-in r [:hits :hits])}
                                    {:target app-root})))}
@@ -110,6 +116,7 @@
 (defn build-main []
   (om/root alert-list app-state {:target app-root}))

+
 (defn main []
   (current-alerts)
   (build-main))


Add keys to elements in mana-cost widget

--- src/cljs/decktouch/widgets.cljs
+++ src/cljs/decktouch/widgets.cljs
@@ -35,7 +35,7 @@
             (for [m (keys sorted-mana-symbol-counts)]
               (let [n (sorted-mana-symbol-counts m)]
                 (if (> n 0)
-                  [mana-symbol m n])))]
+                  ^{:key m} [mana-symbol m n])))]
       [:br]]))

 (defn card-counter [cards]


Adapted targeting friendly units

Adapted targeting friendly units

--- src/cljs/zetawar/events/ui.cljs
+++ src/cljs/zetawar/events/ui.cljs
@@ -97,7 +97,8 @@
                 (or selected-unit selected-terrain)
                 (game/can-repair-other? db game selected-unit)
                 (game/can-be-repaired? db game unit)
-                (game/in-range? db selected-unit unit))
+                (game/in-range? db selected-unit unit)
+                (game/compatible-armor-types-for-repair? db game selected-unit unit))
              [{:db/id (e app)
                :app/targeted-q ev-q
                :app/targeted-r ev-r}]


Removing with-out-str

Removing with-out-str

--- src/com/akr/ez_patcher/core.clj
+++ src/com/akr/ez_patcher/core.clj
@@ -177,15 +177,13 @@
       obj)))

 (defn -updateWith [self obj string]
-  (with-out-str
-    (let [hsh (parse-string string)]
-      (cond (= (empty hsh) {}) (update-with obj hsh)
-            (= (empty hsh) []) (throw "Array class unspecified.")
-            :else hsh))))
+  (let [hsh (parse-string string)]
+    (cond (= (empty hsh) {}) (update-with obj hsh)
+          (= (empty hsh) []) (throw "Array class unspecified.")
+          :else hsh)))

 (defn -toArray [self string klass]
-  (do  ;with-out-str
-    (let [hsh (parse-string string)]
-      (cond (= (empty hsh) []) (create-array-with hsh klass)
-            :else (throw "Not an array.")))))
+  (let [hsh (parse-string string)]
+    (cond (= (empty hsh) []) (create-array-with hsh klass)
+          :else (throw "Not an array."))))


Update cloudwatch alarm spec (#189)

Update cloudwatch alarm spec (#189)

Properties have been expanded since last update: https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-cw-alarm.html

--- src/crucible/aws/cloudwatch.clj
+++ src/crucible/aws/cloudwatch.clj
@@ -20,15 +20,21 @@
 (s/def ::comparison-operator (spec-or-ref #{"GreaterThanOrEqualToThreshold"
                                             "GreaterThanThreshold"
                                             "LessThanThreshold"
-                                            "LessThanOrEqualToThreshold"}))
+                                            "LessThanOrEqualToThreshold"
+                                            "LessThanLowerThreshold"
+                                            "LessThanLowerOrGreaterThanUpperThreshold"}))

 (s/def ::value (spec-or-ref string?))

 (s/def ::name (spec-or-ref string?))

+(s/def ::datapoints-to-alarm (spec-or-ref int?))
+
 (s/def ::dimension (s/keys :req [::name ::value]))

 (s/def ::dimensions (s/coll-of ::dimension :kind vector?))
+
+(s/def ::evaluate-low-sample-count-percentile (spec-or-ref string?))

 (s/def ::evaluation-periods (spec-or-ref pos-int?))

@@ -39,6 +45,31 @@
 (s/def ::insufficient-data-actions ::actions)

 (s/def ::metric-name (spec-or-ref string?))
+
+(s/def ::expression (spec-or-ref string?))
+
+(s/def ::id (spec-or-ref string?))
+
+(s/def ::label (spec-or-ref string?))
+
+(s/def ::metric (s/keys :opt [::dimensions
+                              ::metric-name
+                              ::namespace]))
+
+(s/def ::metric-stat (s/keys :req [::metric
+                                   ::period
+                                   ::stat]
+                             :opt [::unit]))
+
+(s/def ::return-data (spec-or-ref boolean?))
+
+(s/def ::metric-data-query (s/keys :req [::id]
+                                   :opt [::expression
+                                         ::label
+                                         ::metric-stat
+                                         ::return-data]))
+
+(s/def ::metrics (s/coll-of ::metric-data-query))

 (s/def ::namespace (spec-or-ref string?))

@@ -56,6 +87,8 @@
                                   "Maximum"}))

 (s/def ::threshold (spec-or-ref double?))
+
+(s/def ::threshold-metric-id (spec-or-ref string?))

 (s/def ::treat-missing-data (spec-or-ref #{"breaching"
                                            "notBreaching"
@@ -90,12 +123,10 @@
                              "None"}))

 (s/def ::alarm (s/keys :req [::comparison-operator
-                             ::evaluation-periods
+                             ::evaluation-periods]
+                       :opt [::namespace
                              ::metric-name
-                             ::namespace
-                             ::period
-                             ::threshold]
-                       :opt [::actions-enabled
+                             ::actions-enabled
                              ::alarm-actions
                              ::alarm-description
                              ::alarm-name
@@ -103,6 +134,12 @@
                              ::insufficient-data-actions
                              ::ok-actions
                              ::statistic
-                             ::unit]))
+                             ::unit
+                             ::datapoints-to-alarm
+                             ::evaluate-low-sample-count-percentile
+                             ::metrics
+                             ::period
+                             ::threshold
+                             ::threshold-metric-id]))

 (defresource alarm "AWS::CloudWatch::Alarm" ::alarm)


Cosmetic.

Cosmetic.

--- src/onyx/api.clj
+++ src/onyx/api.clj
@@ -58,7 +58,8 @@
    (map
     (fn [_]
       (let [v-peer (component/start (system/onyx-peer config))]
-        (let [rets {:runner (future (try @(:payload-thread (:peer v-peer)) (catch Exception e (.printStackTrace e))))
+        (let [rets {:runner (future (try @(:payload-thread (:peer v-peer))
+                                         (catch Exception e (.printStackTrace e))))
                     :shutdown-fn (fn [] (component/stop v-peer))}]
           (register-peer coord (:peer-node (:peer v-peer)))
           rets)))


Remove unused variables.

Remove unused variables.

--- src/klangmeister/instruments.cljs
+++ src/klangmeister/instruments.cljs
@@ -23,7 +23,6 @@
 (defn bell! [midi start dur]
   (let [freq (music/equal-temperament midi)
         start (+ start (.-currentTime context))
-        stop (+ start dur)
         harmonic (fn [n proportion]
                    (let [mid (+ start 0.01)
                          gainNode (doto (.createGain context)
@@ -45,7 +44,6 @@
 (defn fuzz! [midi start dur]
   (let [freq (music/equal-temperament midi)
         start (+ start (.-currentTime context))
-        stop (+ start dur)
         envelope (perc start 0.1 0.5)]
     (doto (.createOscillator context)
       (-> .-frequency .-value (set! freq))


t-thomsky: Add a bunch of test cases

t-thomsky: Add a bunch of test cases

All for the old single-valued? predicate.

--- test/cljs/theatralia/t_thomsky.cljs
+++ test/cljs/theatralia/t_thomsky.cljs
@@ -1,5 +1,5 @@
 (ns theatralia.t-thomsky
-  (:require [cljs.test :refer-macros [deftest is are run-tests]]
+  (:require [cemerick.cljs.test :refer-macros [deftest is are run-tests]]
             [theatralia.thomsky :as tsky]))

 ;;; Credits: @#' swearing in order to access private vars is recommended here:
@@ -8,6 +8,157 @@
 ;;; https://groups.google.com/d/topic/clojure/Mi277rszUs0/discussion, too, if
 ;;; you intend to use this in other places.

+;; These are most of the queries from http://docs.datomic.com/query.html. Errm,
+;; couldn't stop myself…
 (deftest test-single-valued?
   (are [b q] (= b (@#'tsky/single-valued? q))
-       true '[:find ?e . :where [?e :attr _]]))
+       true '[:find ?e . :where [?e :attr _]]
+       true '{:find [[?year ?month ?day]]
+              :in [$ ?name]
+              :where [[?artist :artist/name ?name]
+                      [?artist :artist/startDay ?day]
+                      [?artist :artist/startMonth ?month]
+                      [?artist :artist/startYear ?year]]}
+       true '[:find [?year ?month ?day]
+              :in $ ?name
+              :where [?artist :artist/name ?name]
+              [?artist :artist/startDay ?day]
+              [?artist :artist/startMonth ?month]
+              [?artist :artist/startYear ?year]]
+       true '[:find ?year .
+              :in $ ?name
+              :where [?artist :artist/name ?name]
+              [?artist :artist/startYear ?year]]
+       true '[:find (count ?eid) .
+              :where [?eid :artist/name]
+              (not [?eid :artist/country :country/CA])]
+       true '[:find (count ?artist) .
+              :where [?artist :artist/name]
+              (not-join [?artist]
+                        [?release :release/artists ?artist]
+                        [?release :release/year 1970])]
+       true '[:find (count ?r) .
+              :where [?r :release/name "Live at Carnegie Hall"]
+              (not-join [?r]
+                        [?r :release/artists ?a]
+                        [?a :artist/name "Bill Withers"])]
+       true '[:find (count ?medium) .
+              :where (or [?medium :medium/format :medium.format/vinyl7]
+                         [?medium :medium/format :medium.format/vinyl10]
+                         [?medium :medium/format :medium.format/vinyl12]
+                         [?medium :medium/format :medium.format/vinyl])]
+       true '[:find (count ?artist) .
+              :where (or [?artist :artist/type :artist.type/group]
+                         (and [?artist :artist/type :artist.type/person]
+                              [?artist :artist/gender :artist.gender/female]))]
+       true '[:find (count ?release) .
+              :where [?release :release/name]
+              (or-join [?release]
+                       (and [?release :release/artists ?artist]
+                            [?artist :artist/country :country/CA])
+                       [?release :release/year 1970])]
+       true '[:find ?celsius .
+              :in ?fahrenheit
+              :where [(- ?fahrenheit 32) ?f-32]
+              [(/ ?f-32 1.8) ?celsius]]
+       true '[:find [?e ?attr ?name]
+              :in $ ?e
+              :where [(get-some $ ?e :country/name :artist/name) [?attr ?name]]]
+       true '[:find (sum ?heads) .
+              :in [[_ ?heads]]]
+       true '[:find (sum ?heads) .
+              :with ?monster
+              :in [[?monster ?heads]]]
+       true '[:find [(min ?dur) (max ?dur)]
+              :where [_ :track/duration ?dur]]
+       true '[:find (sum ?count) .
+              :with ?medium
+              :where [?medium :medium/trackCount ?count]]
+       true '[:find (user/mode ?track-count) .
+              :with ?media
+              :where [?media :medium/trackCount ?track-count]]
+       false '[:find ?e ?x
+               :where [?e :age 42] [?e :likes ?x]]
+       false '[:find ?x
+               :where [_ :likes ?x]]
+       false '[:find ?release-name
+               :in $
+               :where [$ _ :release/name ?release-name]]
+       false '[:find ?release-name
+               :in $ ?artist-name
+               :where [?artist :artist/name ?artist-name]
+               [?release :release/artists ?artist]
+               [?release :release/name ?release-name]]
+       false '[:find ?release
+               :in $ [?artist-name ?release-name]
+               :where [?artist :artist/name ?artist-name]
+               [?release :release/artists ?artist]
+               [?release :release/name ?release-name]]
+       false '[:find ?release-name
+               :in $ [?artist-name ...]
+               :where [?artist :artist/name ?artist-name]
+               [?release :release/artists ?artist]
+               [?release :release/name ?release-name]]
+       false '[:find ?release
+               :in $ [[?artist-name ?release-name]]
+               :where [?artist :artist/name ?artist-name]
+               [?release :release/artists ?artist]
+               [?release :release/name ?release-name]]
+       false '[:find ?artist-name ?release-name
+               :where [?release :release/name ?release-name]
+               [?release :release/artists ?artist]
+               [?artist :artist/name ?artist-name]]
+       false '[:find [?release-name ...]
+               :in $ ?artist-name
+               :where [?artist :artist/name ?artist-name]
+               [?release :release/artists ?artist]
+               [?release :release/name ?release-name]]
+       false '[:find ?name ?year
+               :where [?artist :artist/name ?name]
+               [?artist :artist/startYear ?year]
+               [(< ?year 1600)]]
+       false '[:find ?track-name ?minutes
+               :in $ ?artist-name
+               :where [?artist :artist/name ?artist-name]
+               [?track :track/artists ?artist]
+               [?track :track/duration ?millis]
+               [(quot ?millis 60000) ?minutes]
+               [?track :track/name ?track-name]]
+       false '[:find ?artist-name ?year
+               :in $ [?artist-name ...]
+               :where [?artist :artist/name ?artist-name]
+               [(get-else $ ?artist :artist/startYear "N/A") ?year]]
+       false '[:find ?entity ?name ?tx ?score
+               :in $ ?search
+               :where [(fulltext $ :artist/name ?search) [[?entity ?name ?tx ?score]]]]
+       false '[:find ?name
+               :where [?artist :artist/name ?name]
+               [(missing? $ ?artist :artist/startYear)]]
+       false '[:find [?tx ...]
+               :in ?log
+               :where [(tx-ids ?log 1000 1050) [?tx ...]]]
+       false '[:find [?e ...]
+               :in ?log ?tx
+               :where [(tx-data ?log ?tx) [[?e]]]]
+       false '[:find ?k ?v
+               :where [(System/getProperties) [[?k ?v]]]]
+       false '[:find (count ?name) (count-distinct ?name)
+               :with ?artist
+               :where [?artist :artist/name ?name]]
+       false '[:find ?year (median ?namelen) (avg ?namelen) (stddev ?namelen)
+               :with ?track
+               :where [?track :track/name ?name]
+               [(count ?name) ?namelen]
+               [?medium :medium/tracks ?track]
+               [?release :release/media ?medium]
+               [?release :release/year ?year]]
+       false '[:find (pull ?e [:release/name])
+               :in $ ?artist
+               :where [?e :release/artists ?artist]]
+       false '[:find (pull ?e pattern)
+               :in $ ?artist pattern
+               :where [?e :release/artists ?artist]]
+       false '{:find [?e]
+               :in [$ ?fname ?lname]
+               :where [[?e :user/firstName ?fname]
+                       [?e :user/lastName ?lname]]}))


walker tests

walker tests

--- test/com/rpl/specter/core_test.cljc
+++ test/com/rpl/specter/core_test.cljc
@@ -1548,6 +1548,19 @@
   (is (= {[2] 4} (let [a 1] (transform (s/keypath [(inc2 a)]) inc {[2] 3}))))
   )

+(defrecord FooW [a b])
+
+(deftest walker-test
+  (is (= [1 2 3 4 5 6] (select (s/walker number?) [{1 2 :b '(3 :c 4)} 5 #{6 :d}])))
+  (is (= [{:b '(:c)} #{:d}] (setval (s/walker number?) s/NONE [{:q 3 10 :l 1 2 :b '(3 :c 4)} 5 #{6 :d}])))
+  (is (= [{:q 4 11 :l 2 3 :b '(4 :c 5)} 6 #{7 :d}]
+         (transform (s/walker number?) inc [{:q 3 10 :l 1 2 :b '(3 :c 4)} 5 #{6 :d}])))
+  (let [f (->FooW 1 2)]
+    (is (= [[:a 1] [:b 2]] (select (s/walker (complement record?)) f)))
+    (is (= (assoc f :a! 1 :b! 2) (setval [(s/walker (complement record?)) s/FIRST s/NAME s/END] "!" f)))
+    (is (= (assoc f :b 1 :c 2) (transform [(s/walker (complement record?)) s/FIRST] (fn [k] (if (= :a k) :b :c)) f)))
+    ))
+
 #?(:clj
   (do
     (defprotocolpath FooPP)


fix containers setup

fix containers setup

--- frontend/models/build.cljs
+++ frontend/models/build.cljs
@@ -143,11 +143,14 @@

 (defn containers [build]
   (let [steps (:steps build)
+        parallel (:parallel build)
         actions (reduce (fn [groups step]
                           (map (fn [group action]
                                  (conj group action))
-                               groups (lazy-cat (:actions step))))
-                        (repeat (or (:parallel build) 1) [])
+                               groups (if (> parallel (count (:actions step)))
+                                        (apply concat (repeat parallel (:actions step)))
+                                        (:actions step))))
+                        (repeat (or parallel 1) [])
                         steps)]
     (map (fn [i actions] {:actions actions
                           :index i})


Increase timeouts

Increase timeouts

--- test/powderkeg/integration_test.clj
+++ test/powderkeg/integration_test.clj
@@ -57,9 +57,9 @@
 (defn with-cluster [f]
   (let [pwd (.getAbsolutePath (java.io.File. ""))]
     (start-master pwd)
-    (Thread/sleep 2000)
+    (Thread/sleep 4000)
     (start-worker pwd)
-    (Thread/sleep 2000))
+    (Thread/sleep 4000))
   (f)
   (stop-spark "worker")
   (stop-spark "master"))


Places import: title is the same for each returned row. Don't filter.

--- src/datomish/places/import.cljc
+++ src/datomish/places/import.cljc
@@ -55,7 +55,7 @@

 (defn- place->entity [[id rows]]
-  (let [title (:title (first (filter :page/title rows)))
+  (let [title (:title (first rows))
         required {:db/id (db/id-literal :db.part/user)
                   :page/url (:url (first rows))
                   :page/guid (:guid (first rows))}


Make `delete` function of localfs storage exception safe.

--- src/datoteka/storages/local.clj
+++ src/datoteka/storages/local.clj
@@ -33,6 +33,7 @@
            java.net.URI
            java.nio.file.Path
            java.nio.file.Files
+           java.nio.file.NoSuchFileException
            java.util.function.Supplier
            java.util.concurrent.CompletableFuture
            java.util.concurrent.ExecutorService
@@ -67,7 +68,11 @@
   [base path]
   (let [path (->> (pt/-path path)
                   (normalize-path base))]
-    (fs/delete-single path)))
+    (try
+      (fs/delete path)
+      true
+      (catch java.nio.file.NoSuchFileException e
+        false))))

 (defn- submit
   [executor func]


Add default resize logic implementation for shapes.


support creating a game with an arbitrary player

--- src/greybear/pages/new_game.clj
+++ src/greybear/pages/new_game.clj
@@ -31,8 +31,9 @@
                  [:div.col-md-5]
                  [:div.col-md-2
                   [:form {:method "post" :action "/new-game"}
-                   [:input {:type "hidden" :name "user-id"
+                   [:input {:type "hidden" :name "my-id"
                             :value (get-user-id request)}]
+                   [:input {:type "text" :name "opponent-id"}]
                    [:button.btn.btn-success "New Game"]]]
                  [:div.col-md-5]]
                 [:div.row
@@ -41,4 +42,6 @@
 (defn new-game-post [params]
   (friend/authenticated
    (resp/redirect
-    (str "/games/" (create-game (parse-int (params :user-id)) 1)))))
+    (str "/games/" (create-game
+                    (parse-int (params :my-id))
+                    (parse-int (params :opponent-id)))))))


import

import

--- src/hackerrank/clojure_libs.clj
+++ src/hackerrank/clojure_libs.clj
@@ -67,6 +67,13 @@
 ;; (reverse "foobar")

 ;; use :as
-(use '[clojure.string :as str :only [join split]])
-(str/replace "foobar" "f" "p")
+;; (use '[clojure.string :as str :only [join split]])
+;; (str/replace "foobar" "f" "p")
 ;; same as require, so dont use it better
+
+;; Working with Java and deftypes/defrecords: import
+
+;; import
+(java.util.Date.)
+(import 'java.util.Date)
+(Date.)


Refactored 'check' task (to consist of reusable parts).

--- src/leiningen/ancient/check.clj
+++ src/leiningen/ancient/check.clj
@@ -1,23 +1,27 @@
 (ns ^{ :doc "Check for outdated dependencies."
        :author "Yannick Scherer" }
   leiningen.ancient.check
-  (:require [leiningen.ancient.utils.projects :refer [collect-artifacts collect-repositories]]
+  (:require [leiningen.ancient.utils.projects :refer [collect-artifacts artifact-path collect-repositories]]
             [leiningen.ancient.utils.cli :refer [parse-cli]]
             [ancient-clj.verbose :refer :all]
             [ancient-clj.core :as anc]))

-;; ## Actual Check Logic
+;; ## Check/Update

-(defn- check-artifacts
-  "Check the given artifacts for outdated dependencies."
+(defn check-artifact!
+  "Checks the given artifact and stores the latest version in `:latest`."
+  [repos settings {:keys [group-id artifact-id version] :as artifact}]
+  (let [path (artifact-path artifact)]
+    (verbose "Checking " group-id "/" artifact-id " (current version: " (version-string version)
+             " at " (artifact-path artifact) ") ...")
+    (assoc artifact :latest (anc/artifact-outdated? settings repos artifact))))
+
+(defn get-outdated-artifacts!
+  "Get (a lazy seq of) all outdated artifacts (with the latest version in `:latest`).
+   Input and Output are artifact maps."
   [repos settings artifacts]
-  (doseq [{:keys [group-id artifact-id version] :as artifact} artifacts]
-    (verbose "Checking " group-id "/" artifact-id " (current version: " (version-string version) ") ...")
-    (when-let [latest (anc/artifact-outdated? settings repos artifact)]
-      (println
-        (artifact-string group-id artifact-id latest)
-        "is available but we use"
-        (yellow (version-string version))))))
+  (let [checked-artifacts (map #(check-artifact! repos settings %) artifacts)]
+    (filter :latest checked-artifacts)))

 ;; ## Task

@@ -27,7 +31,12 @@
   (let [settings (parse-cli args)]
     (with-settings settings
       (let [repos (collect-repositories project)
-            artifacts (collect-artifacts project settings)]
+            artifacts (collect-artifacts project settings)
+            outdated (get-outdated-artifacts! repos settings artifacts)]
         (verbose "Checking " (count artifacts) " Dependencies using " (count repos) " Repositories ...")
-        (check-artifacts repos settings artifacts)
+        (doseq [{:keys [group-id artifact-id version latest]} outdated]
+          (println
+            (artifact-string group-id artifact-id latest)
+            "is available but we use"
+            (yellow (version-string version))))
         (verbose "Done.")))))