Improve document

Improve document

--- src/control/core.clj
+++ src/control/core.clj
@@ -12,38 +12,35 @@
 (def ^:private bash-redbold "\033[1;31m")
 (def ^:private bash-greenbold "\033[1;32m")

-(defmacro cli-bash-bold [& content]
+(defmacro ^:private cli-bash-bold [& content]
   `(if *enable-color*
      (str bash-bold ~@content bash-reset)
      (str ~@content)))

-(defmacro cli-bash-redbold [& content]
+(defmacro ^:private cli-bash-redbold [& content]
   `(if *enable-color*
      (str bash-redbold ~@content bash-reset)
      (str ~@content)))

-(defmacro cli-bash-greenbold [& content]
+(defmacro ^:private cli-bash-greenbold [& content]
   `(if *enable-color*
      (str bash-greenbold ~@content bash-reset)
      (str ~@content)))

-(defstruct ExecProcess  :stdout :stderr :status)
+(defstruct ^:private ExecProcess  :stdout :stderr :status)

 (defn gen-log [host tag content]
   (str (cli-bash-redbold host ":")
        (cli-bash-greenbold tag ": ")
        (join " " content)))

-(defn log-with-tag [host tag & content]
+(defn-  log-with-tag [host tag & content]
   (if (and *enable-logging* (not (blank? (join " " content))))
     (println (gen-log host tag content))))

-(defn- not-nil? [obj]
-  (not (nil? obj)))
-
 (defn  ^:dynamic  exec [host user cmdcol]
-  (let [rt (apply sh (filter not-nil? cmdcol))
+  (let [rt (apply sh (filter (complement nil?) cmdcol))
         status (:exit rt)
         stdout (:out rt)
         stderr (:err rt)
@@ -56,7 +53,7 @@
 (defn ssh-client [host user]
   (str user "@" host))

-(defn- user-at-host? [host user]
+(defn-  user-at-host? [host user]
   (fn [m]
     (and (= (:user m) user) (= (:host m) host))))

@@ -74,14 +71,20 @@
   "Execute commands via ssh:
    (ssh \"date\")
    (ssh \"ps aux|grep java\")
+   (ssh \"sudo apt-get update\" :sudo true)
+
+   Valid options:
+   :sudo   whether to run commands as root,default is false
+   :ssh-options  -- ssh options string
 "
+  {:arglists '([cmd & opts])}
   [host user cluster cmd & opts]
   (let [m (apply hash-map opts)
         sudo (:sudo m)
         cmd (if sudo
               (str "sudo " cmd)
               cmd)
-        ssh-options (or (:ssh-options opts) (find-client-options host user cluster :ssh-options))]
+        ssh-options (or (:ssh-options m) (find-client-options host user cluster :ssh-options))]
 	(log-with-tag host "ssh" ssh-options cmd)
 	(exec host
           user
@@ -89,8 +92,18 @@
                           ssh-options
                           [(ssh-client host user) cmd]))))

-(defn rsync [host user cluster src dst]
-  (let [rsync-options (find-client-options host user cluster :rsync-options)]
+(defn rsync
+  "Rsync local files to remote machine's files,for example:
+     (deftask :deploy \"scp files to remote machines\" []
+    (rsync \"src/\" \":/home/login\"))
+
+    Valid options:
+    :rsync-options  -- rsync options string
+  "
+  {:arglists '([src dst & opts])}
+  [host user cluster src dst & opts]
+  (let [m (apply hash-map opts)
+        rsync-options (or (:rsync-options m) (find-client-options host user cluster :rsync-options))]
     (log-with-tag host "rsync" rsync-options (str src " ==>" dst))
     (exec host
           user
@@ -103,8 +116,14 @@
 (defn scp
   "Copy local files to remote machines:
    (scp \"test.txt\" \"remote.txt\")
-   (scp [\"1.txt\" \"2.txt\"] \"/home/deploy/\")
+   (scp [\"1.txt\" \"2.txt\"] \"/home/deploy/\" :sudo true :mode 755)
+
+  Valid options:
+    :sudo  -- whether to copy files to remote machines as root
+    :mode -- files permission on remote machines
+    :scp-options -- scp options string
 "
+  {:arglists '([local remote & opts])}
   [host user cluster local remote & opts]
   (let [files (if (coll? local)
                 (vec local)
@@ -144,6 +163,8 @@
   ^{:doc "Define a task for executing on remote machines:
            (deftask :date \"Get date from remote machines\"
                      (ssh \"date\"))
+
+          Please see https://github.com/killme2008/clojure-control/wiki/Define-tasks
 "
     :arglists '([name doc-string? [params*] body])
     :added "0.1"}
@@ -175,15 +196,17 @@
 (defn call
   "Call other tasks in deftask,for example:
      (call :ps \"java\")"
+  {:arglists '([task & args])}
   [host user cluster task & args]
   (apply
    (task @tasks)
    host user cluster args))

 (defn exists?
-  "Check if a file exists"
+  "Check if a file or directory is exists"
+  {:arglists '([file])}
   [host user cluster file]
-  (= (:status (ssh host user cluster (str "test -e " file))) 0))
+  (zero? (:status (ssh host user cluster (str "test -e " file)))))

 (defn- unquote-cluster [args]
@@ -198,14 +221,20 @@
         args))

 (defmacro
-  ^{:doc "Define a cluster including some remote machines"
+  ^{:doc "Define a cluster including some remote machines,for example:
+           (defcluster :mycluster
+                     :user \"login\"
+                     :addresses [\"a.domain.com\" \"b.domain.com\"])
+
+      Please see https://github.com/killme2008/clojure-control/wiki/Define-clusters
+     "
     :arglists '([name & options])
     :added "0.1"}
   defcluster [name & args]
   `(let [m# (apply hash-map ~(cons 'list (unquote-cluster args)))]
      (swap! clusters assoc ~name (assoc m# :name ~name))))

-(defmacro when-exit
+(defmacro ^:private when-exit
   ([test error]
      `(when-exit ~test ~error nil))
   ([test error else]


tests for :anewarray and :instanceof

tests for :anewarray and :instanceof

--- test/insn/core_test.clj
+++ test/insn/core_test.clj
@@ -11,6 +11,18 @@

 (defn make [& {:as m}]
   (core/new-instance m))
+
+(deftest test-anewarray
+  (let [obj (make
+             :methods [{:name "go", :desc [[Object]]
+                        :emit [[:ldc 1]
+                               [:anewarray Object]
+                               [:dup]
+                               [:ldc 0]
+                               [:ldc "foo"]
+                               [:aastore]
+                               [:areturn]]}])]
+    (is (= "foo" (-> (.go obj) (aget 0))))))

 (deftest test-casts
   (let [obj (make
@@ -54,6 +66,17 @@

     (testing "static"
       (is (= 17 (eval `(. ~cname y)))))))
+
+(deftest test-instanceof
+  (let [obj (make
+             :methods [{:name "go", :desc [Object Object :int]
+                        :emit [[:aload 1]
+                               [:instanceof String]
+                               [:aload 2]
+                               [:instanceof [Long]]
+                               [:iadd]
+                               [:ireturn]]}])]
+    (is (= 2 (.go obj "foo" (into-array Long [42]))))))

 (deftest test-ldc
   (let [obj (make


CMR-1415: Added tests for find by concept-id

--- system-int-test/test/cmr/system_int_test/search/collection_concept_revision_search_test.clj
+++ system-int-test/test/cmr/system_int_test/search/collection_concept_revision_search_test.clj
@@ -142,6 +142,28 @@
               [coll3+metadata]
               {:entry-title "et3" :latest true}

+              "concept-id - latest=true"
+              [coll2-3]
+              {:concept-id (:concept-id coll2-1) :exclude-metadata true :latest true}
+
+              "concept-id - all revisions"
+              [coll2-1 coll2-tombstone coll2-3]
+              {:concept-id (:concept-id coll2-1) :exclude-metadata true :latest false}
+
+              "concept-id, version-id - latest=true"
+              ;; TODO - this should find nothing when the "find latest" logic is updated
+              [coll1-1] {:concept-id (:concept-id coll1-1)
+                         :version-id "v1"
+                         :exclude-metadata true
+                         :latest true}
+
+              "concept-id, version-id - all revisions"
+              [coll2-1 coll2-tombstone]
+              {:concept-id (:concept-id coll2-1)
+               :version-id "v2"
+               :exclude-metadata true
+               :latest false}
+
               "find none - bad provider-id"
               []
               {:provider-id "PROV_NONE" :exclude-metadata true :latest true}


Get rid of unnecessary use of `is` in tests

`test.check` handles this for us so this was entirely redundant.

--- test/superstring/core_test.clj
+++ test/superstring/core_test.clj
@@ -305,7 +305,7 @@
   (prop/for-all [before (gen/not-empty gen/string)
                  needle (gen/not-empty gen/string)
                  after (gen/not-empty gen/string)]
-    (is (str/contains-any? (str before needle after) [needle]))))
+    (str/contains-any? (str before needle after) [needle])))

 (defspec contains-any-can-ignore-case 100
   (prop/for-all [before (gen/not-empty gen/string)
@@ -373,21 +373,21 @@

 (defspec title-case-starts-with-upper 100
   (prop/for-all [s (gen/not-empty gen/string)]
-    (is (upper-if-upper-exists? (first (str/title-case s))))))
+    (upper-if-upper-exists? (first (str/title-case s)))))

 (defspec title-case-rest-is-all-lower-case 100
   (prop/for-all [s (gen/not-empty gen/string)]
-    (is (reduce (fn [acc c] (and acc (lower-if-lower-exists? c))) true
-                (rest (str/title-case s))))))
+    (reduce (fn [acc c] (and acc (lower-if-lower-exists? c))) true
+            (rest (str/title-case s)))))

 (defspec upper-case?-returns-true-on-all-upper 100
   (prop/for-all [s (gen/not-empty gen/string)]
-    (is (str/upper-case? (str/upper-case s)))))
+    (str/upper-case? (str/upper-case s))))

 (defspec upper-case?-returns-nil-on-all-lower 100
   (prop/for-all [s (gen/such-that not-empty
                                   (gen/fmap str/join (gen/vector gen/char-alpha)))]
-    (is (not (str/upper-case? (str/lower-case s))))))
+    (not (str/upper-case? (str/lower-case s)))))

 (deftest upper-case-test
   (str/upper-case? "UPPER") "UPPER"
@@ -395,12 +395,12 @@

 (defspec lower-case?-returns-true-on-all-lower 100
   (prop/for-all [s (gen/not-empty gen/string)]
-    (is (str/lower-case? (str/lower-case s)))))
+    (str/lower-case? (str/lower-case s))))

 (defspec lower-case?-returns-nil-on-all-upper 100
   (prop/for-all [s (gen/such-that not-empty
                                   (gen/fmap str/join (gen/vector gen/char-alpha)))]
-    (is (not (str/lower-case? (str/upper-case s))))))
+    (not (str/lower-case? (str/upper-case s)))))

 (defn- word []
   (gen/fmap #(if (< (.length %) 10)
@@ -415,10 +415,10 @@
   (prop/for-all [words (gen/bind (gen/choose 50 500)
                                  #(gen/return (gen/sample (word) %)))
                  width (gen/choose 8 80)]
-    (is (reduce (fn [acc line]
-                  (and acc (less-than-width-or-unbreakable line width)))
-                true
-                (str/split-lines (str/wrap-words (str/join " " words) width))))))
+    (reduce (fn [acc line]
+              (and acc (less-than-width-or-unbreakable line width)))
+            true
+            (str/split-lines (str/wrap-words (str/join " " words) width)))))

 (defexamples lower-case-test
   (str/lower-case? "upper") "upper"
@@ -426,8 +426,8 @@

 (defspec lisp-case-is-all-lower 100
   (prop/for-all [s (gen/not-empty gen/string)]
-    (is (reduce (fn [acc c] (and acc (lower-if-lower-exists? c))) true
-                (str/lisp-case s)))))
+    (reduce (fn [acc c] (and acc (lower-if-lower-exists? c))) true
+            (str/lisp-case s))))

 (defexamples lisp-case-test
   (str/lisp-case "PascalCase") "pascal-case"
@@ -474,7 +474,7 @@

 (defspec ascii?-returns-s-on-ascii-strings 100
   (prop/for-all [s (gen/not-empty gen/string-ascii)]
-    (is (= s (str/ascii? s)))))
+    (= s (str/ascii? s))))

 (defexamples ascii?-test
   (str/ascii? "ascii") "ascii"
@@ -482,19 +482,19 @@

 (defspec slug-contains-only-ascii-chars 100
   (prop/for-all [s (gen/not-empty gen/string)]
-    (is (str/ascii? (str/slug s)))))
+    (str/ascii? (str/slug s))))

 (defspec slug-contains-no-whitespace 100
   (prop/for-all [s (gen/not-empty gen/string)]
-    (is (not (re-find #"\s+" (str/slug s))))))
+    (not (re-find #"\s+" (str/slug s)))))

 (defspec slug-is-all-lower 100
   (prop/for-all [s (gen/not-empty gen/string)]
-    (is (str/lower-case? (str/slug s)))))
+    (str/lower-case? (str/slug s))))

 (defspec slug-only-contains-unreserved-characters 100
   (prop/for-all [s (gen/not-empty gen/string)]
-    (is (not (re-matches #"[^A-Za-z0-9_.~-]+" (str/slug s))))))
+    (not (re-matches #"[^A-Za-z0-9_.~-]+" (str/slug s)))))

 (defexamples slug-test
   (str/slug "This, That & the Other! Various Outré   Considerations")
@@ -528,8 +528,8 @@
   (prop/for-all [s (gen/not-empty gen/string-alphanumeric)
                  ws1 (gen/not-empty whitespace)
                  ws2 (gen/not-empty whitespace)]
-    (is (= (+ (.length s) 2)
-           (.length (str/collapse-whitespace (str ws1 s ws2)))))))
+    (= (+ (.length s) 2)
+       (.length (str/collapse-whitespace (str ws1 s ws2))))))

 (defexamples collapse-whitespace-test
   (str/collapse-whitespace "foo
@@ -540,25 +540,25 @@
 (defspec levenshtein-distance-is-at-least-difference-between-string-lenghts 100
   (prop/for-all [s1 (gen/not-empty gen/string)
                  s2 (gen/not-empty gen/string)]
-    (is (>= (str/distance s1 s2)
-            (- (max (.length s1) (.length s2))
-               (min (.length s1) (.length s2)))))))
+    (>= (str/distance s1 s2)
+        (- (max (.length s1) (.length s2))
+           (min (.length s1) (.length s2))))))

 (defspec levenshtein-distance-is-at-most-length-of-longest-string 100
   (prop/for-all [s1 (gen/not-empty gen/string)
                  s2 (gen/not-empty gen/string)]
-    (is (<= (str/distance s1 s2)
-            (max (.length s1) (.length s2))))))
+    (<= (str/distance s1 s2)
+        (max (.length s1) (.length s2)))))

 (defspec levenshtein-distance-is-zero-for-equal-strings 100
   (prop/for-all [s (gen/not-empty gen/string)]
-    (is (= 0 (str/distance s s)))))
+    (= 0 (str/distance s s))))

 (defspec levenshtein-distance-is-zero-means-equal-strings 100
   (prop/for-all [s1 (gen/not-empty gen/string)
                  s2 (gen/not-empty gen/string)]
     (if (= (str/distance s1 s2) 0)
-      (is (= s1 s2))
+      (= s1 s2)
       true)))

 (defspec levenshtein-triangle 100
@@ -598,7 +598,7 @@

 (defspec length-test 100
   (prop/for-all [s gen/string]
-    (is (= (.length s) (str/length s)))))
+    (= (.length s) (str/length s))))

 (defexamples index-of-test
   (str/index-of "foo" "foo") 0


Add test for `of-years`

Add test for `of-years`

--- test/tick/api_test.cljc
+++ test/tick/api_test.cljc
@@ -360,7 +360,9 @@
 ;; units.
 (deftest period-functions-test
   (is (= (t/of-days 10) (java.time.Period/ofDays 10)))
-  (is (= (t/of-months 10) (java.time.Period/ofMonths 10))))
+  (is (= (t/of-months 10) (java.time.Period/ofMonths 10)))
+  (is (= (t/of-years 10) (java.time.Period/ofYears 10))))
+

 (deftest predicates-test
   (is (true? (t/clock? (t/clock))))


Re-enable exemplar files that were disabled on update-bin-verify branch

--- test/transit/verify.clj
+++ test/transit/verify.clj
@@ -234,7 +234,7 @@
   [proc encoding opts]
   (let [transit-exemplars (exemplar-transit encoding)]
     (filter #((:pred %) proc encoding opts)
-            [#_{:pred (constantly true)
+            [{:pred (constantly true)
               :desc "exemplar file"
               :input transit-exemplars
               :test-name :exemplar-file


Use literal value when string is provided for union entry on graphql translation


Clutching at straws

Clutching at straws

--- test/tyranitar/integration.clj
+++ test/tyranitar/integration.clj
@@ -76,11 +76,11 @@
                list-body (read-body list)
                tyranitar (:tyranitar (:applications list-body))
                tyranitar-dev-repo-name (:name (first (:repositories tyranitar)))]
-           tyranitar-dev-repo-name => "tyranitar-dev"))
+           tyranitar-dev-repo-name => "tyranitar-poke"))

    (fact "Can list applications in particular environment with right format"
          (let [list (client/get (url+ "/applications/prod"))
                list-body (read-body list)
-               tyranitar (:tyranitar (:applications list-body))
-               tyranitar-prod-repo-name (:name (first (:repositories tyranitar)))]
-           tyranitar-prod-repo-name => "tyranitar-prod")))
+               test (:test (:applications list-body))
+               test-prod-repo-name (:name (first (:repositories test)))]
+           test-prod-repo-name => "test-prod")))


Fic auth tests.

Fic auth tests.

--- test/uxbox/tests/test_auth.clj
+++ test/uxbox/tests/test_auth.clj
@@ -4,6 +4,7 @@
             [promesa.core :as p]
             [clj-http.client :as http]
             [catacumba.testing :refer (with-server)]
+            [buddy.hashers :as hashers]
             [uxbox.persistence :as up]
             [uxbox.frontend.routes :as urt]
             [uxbox.services.auth :as usa]
@@ -18,7 +19,7 @@

 (t/deftest test-success-auth
   (let [user-data {:username "user1"
-                   :password "user1"
+                   :password  (hashers/encrypt "user1")
                    :email "user1@uxbox.io"}
         user (with-open [conn (up/get-conn)]
                (usa/create-user conn user-data))
@@ -31,7 +32,7 @@

 (t/deftest test-success-by-email
   (let [user-data {:username "user1"
-                   :password "user1"
+                   :password  (hashers/encrypt "user1")
                    :email "user1@uxbox.io"}
         user (with-open [conn (up/get-conn)]
                (usa/create-user conn user-data))
@@ -44,7 +45,7 @@

 (t/deftest test-failed-auth
   (let [user-data {:username "user2"
-                   :password "user2"
+                   :password  (hashers/encrypt "user2")
                    :email "user2@uxbox.io"}
         user (with-open [conn (up/get-conn)]
                (usa/create-user conn user-data))
@@ -64,7 +65,7 @@

 (t/deftest test-http-success-auth
   (let [data {:username "user1"
-              :password "user1"
+              :password  (hashers/encrypt "user1")
               :email "user1@uxbox.io"}
         user (with-open [conn (up/get-conn)]
                (usa/create-user conn data))]
@@ -83,7 +84,7 @@

 (t/deftest test-http-failed-auth
   (let [data {:username "user1"
-              :password "user1"
+              :password  (hashers/encrypt "user1")
               :email "user1@uxbox.io"}
         user (with-open [conn (up/get-conn)]
                (usa/create-user conn data))]


(SERVER-1591) Handle managed dependencies

Prior to this commit, there were some places in ezbake where it
does things to resolve maven dependencies.  The relevant code
did not take into account the new `:managed-dependencies`
capabilities in lein 2.7.  This commit adds in the appropriate
handling of those dependencies where necessary.

--- src/puppetlabs/ezbake/dependency_utils.clj
+++ src/puppetlabs/ezbake/dependency_utils.clj
@@ -4,7 +4,8 @@
   (:require [cemerick.pomegranate.aether :as aether]
             [me.raynes.fs :as fs]
             [clojure.string :as str]
-            [leiningen.core.main :as lein-main]))
+            [leiningen.core.main :as lein-main]
+            [leiningen.core.classpath :as classpath]))

 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;; Internal, non-API functions
@@ -25,7 +26,9 @@

 (defn get-relevant-deps
   [lein-project]
-  (filter include-dep? (:dependencies lein-project)))
+  (-> (filter include-dep? (:dependencies lein-project))
+      (classpath/merge-versions-from-managed-coords
+       (:managed-dependencies lein-project))))

 (defn find-maven-jar-file
   [coords lein-project]
@@ -194,6 +197,7 @@
           (:dependencies lein-project)
           (aether/resolve-dependencies
             :coordinates (:dependencies lein-project)
+            :managed-coordinates (:managed-dependencies lein-project)
             :repositories (:repositories lein-project)
             :local-repo (:local-repo lein-project)
             :mirrors (:mirrors lein-project)))


made util tree functions private

made util tree functions private

--- src/glasses/tree.clj
+++ src/glasses/tree.clj
@@ -3,11 +3,11 @@
             [glasses.traversals :as travers]
             [clojure.walk       :as walk]))

-(defn view-tree [traversal node]
+(defn- view-tree [traversal node]
   (cons node (mapcat (partial view-tree traversal)
                      (lens/view node traversal))))

-(defn pre-replace-tree
+(defn- pre-replace-tree
   [traversal f node]
   (lens/update
    (f node)
@@ -20,7 +20,7 @@
      [(view-tree traversal node)
       (fn [f] (pre-replace-tree traversal f node))])))

-(defn post-replace-tree
+(defn- post-replace-tree
   [traversal f node]
   (f (lens/update
       traversal


Edited one file

Edited one file

--- src/clojush/problems/software/replace_space_with_newline_c.clj
+++ src/clojush/problems/software/replace_space_with_newline_c.clj
@@ -98,16 +98,15 @@
    Returns the behaviors, a list of the outputs of the program on the inputs."
   [program cases]
   (flatten
-   (doall
-    (for [[input output] cases]
-      (let [final-state (run-push program
-                                  (->> (make-push-state)
-                                       (push-item input :input)
-                                       (push-item "" :output)
-                                       (tagspace-initialization (str program) 100)))
-            printed-result (stack-ref :output 0 final-state)
-            int-result (stack-ref :integer 0 final-state)]
-        (vector printed-result int-result))))))
+    (let [state-with-tags (tagspace-initialization (str program) 1000 (make-push-state))]
+      (doall
+       (for [[input output] cases]
+         (let [final-state (run-push program
+                                     (->> (push-item input :input state-with-tags)
+                                          (push-item "" :output)))
+               printed-result (stack-ref :output 0 final-state)
+               int-result (stack-ref :integer 0 final-state)]
+           (vector printed-result int-result)))))))

 (defn replace-space-with-newline-errors-from-behaviors
   "Takes a list of behaviors across the list of cases and finds the error


change api port to be less conflicting

change api port to be less conflicting

--- app/src/semtag_web/config.clj
+++ app/src/semtag_web/config.clj
@@ -1,5 +1,5 @@
 (ns ^:shared semtag-web.config)

 (def config
-  {:api-uri "http://localhost:3000/api"
+  {:api-uri "http://localhost:3030/api"
    :read-only false})


Reducing frequency of the pop-balancer

Reducing frequency of the pop-balancer

--- src/amindblowingworld/civs.clj
+++ src/amindblowingworld/civs.clj
@@ -151,12 +151,17 @@
     (f)
     (run-every-second f)))

+(defn run-every-n-seconds [f n]
+  (future (Thread/sleep (* n 1000))
+    (f)
+    (run-every-n-seconds f n)))
+
 (defn run-randomly [f min max]
   (future (Thread/sleep (+ min (rand-int (- max min))))
     (f)
-    (run-every-second f)))
+    (run-randomly f min max)))

 (defn init []
-  (run-every-second pop-balancer))
+  (run-every-n-seconds pop-balancer 10))


DD exps

DD exps

--- src/angelic/scripts/thesis.clj
+++ src/angelic/scripts/thesis.clj
@@ -242,6 +242,9 @@
              512 nil ::ExpResult)))
       (count +dm-sizes+) +dm-reps+]]))

+#_ (do (use 'angelic.scripts.thesis 'angelic.util.experiments 'angelic.util.cluster)
+       (cluster-smart-runner (make-dm-exps) false (str *default-run-dir* "/thesis-dm/")))
+

 (comment
  ;; DASH-A* blows the stack on the cluster for no good reason, so I'm running
@@ -285,6 +288,68 @@

+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;;;;;;;;;;;;;;;;;;;;;;;; DASH experiments ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+
+(defn interpolating-heuristic [w depth]
+  #(+ w (* (- 1.0 w) (/ % depth))))
+
+(defn top? [r]
+  (when-let [n (-> r :ts-sp :name)]
+    (when (= (first n) :Pair)
+      (let [n (nth n 2)]
+        (when (= (first n) :SA)
+          (let [n (angelic.search.function-sets/fs-name (second (second n)))]
+;            (println (= n [:dash-tla])) (Thread/sleep 100)
+            (= n [:dash-tla])))))))
+
+(defn flast-choice [s]
+  (if (top? (last s))
+    (last s)
+    (first s)))
+
+
+(defn ddh [e] (dd/make-dash-hierarchy e (interpolating-heuristic 0.9 (:depth e))))
+
+(def dd-algs
+  [["dijkstra" `(textbook/uniform-cost-search ~'init true)]
+   ["inv-dsh-ucs" `(hes/dsh-ucs-inverted (ddh ~'init))]
+   ["optimistic-ah-astar" `(aha/optimistic-ah-a* (ddh ~'init) true)]
+   ["dash-astar" `(da/implicit-dash-a* (ddh ~'init))]])
+
+
+(def +dd-sizes+ 1 #_ 10)
+(def +dd-reps+ 1 #_ 3)
+
+(defn make-dd-exps [& [test]]
+  (for [[pn pf] [["num"  (fn [s] [(+ 1 s) 3 3])]
+                 ["size" (fn [s] [1 (+ 2 s) 3])]
+                 ["both" (fn [s] [(+ 1 s) (+ 2 s) 3])]]
+        [n f] dd-algs]
+    [(str pn "_" n)
+     [(fn [sz rep]
+        (let [[sps bits target-count :as args] (pf sz)]
+            (experiments/make-experiment
+             (str pn "_" n "-" sz "-" rep)
+             {:problem pn :alg n :size-i sz :sps sps :bits bits :target-count target-count}
+             'angelic.scripts.thesis
+             `(dd/make-dash-env ~sps ~bits ~target-count)
+             f
+             nil 1
+             ;10 3600
+             512 nil ::ExpResult)))
+      +dd-sizes+ +dd-reps+]]))
+
+#_ (do (use 'angelic.scripts.thesis 'angelic.util.experiments 'angelic.util.cluster)
+       (cluster-smart-runner (make-dd-exps) false (str *default-run-dir* "/thesis-dd/")))
+
+
+;; Note: right factoring is crucial! (hsould also sub-factor tla refs?)
+;; hierarchical hurts here.

@@ -406,22 +471,7 @@
       (println (pad-right n 20)
                (update-in (run-timed f) [0 0] count)))))

-(defn interpolating-heuristic [w depth]
-  #(+ w (* (- 1.0 w) (/ % depth))))
-
-(defn top? [r]
-  (when-let [n (-> r :ts-sp :name)]
-    (when (= (first n) :Pair)
-      (let [n (nth n 2)]
-        (when (= (first n) :SA)
-          (let [n (angelic.search.function-sets/fs-name (second (second n)))]
-;            (println (= n [:dash-tla])) (Thread/sleep 100)
-            (= n [:dash-tla])))))))
-
-(defn flast-choice [s]
-  (if (top? (last s))
-    (last s)
-    (first s)))
+

 ;; TODO: first-last ordering.
 ;; Note: right factoring is crucial! (hsould also sub-factor tla refs?)
@@ -435,10 +485,10 @@
             [#_ ["dijkstra "#(textbook/uniform-cost-search e true)]
              ["dash-a*" #(da/implicit-dash-a* h8i)]
              ["dash-a*" #(da/implicit-dash-a* h8i :choice-fn flast-choice)]
-             ["dash-a*" #(da/implicit-dash-a* h8i :collect? :hierarchical)]
-             ["dash-a*" #(da/implicit-dash-a* h8i :choice-fn flast-choice :collect? :hierarchical)]
+             #_["dash-a*" #(da/implicit-dash-a* h8i :collect? :hierarchical)]
+             #_["dash-a*" #(da/implicit-dash-a* h8i :choice-fn flast-choice :collect? :hierarchical)]
              #_ ["1.0-a*" #(textbook/a*-search e (partial dd/simple-dash-heuristic e 1) true)]
-             ["0.9-a*" #(textbook/a*-search e (partial dd/simple-dash-heuristic e 0.9) true)]
+             #_ ["0.9-a*" #(textbook/a*-search e (partial dd/simple-dash-heuristic e 0.9) true)]
              #_ ["0.8-a*" #(textbook/a*-search e (partial dd/simple-dash-heuristic e 0.8) true)]

              #_ ["1.0-opt-ah-a*"
@@ -451,7 +501,7 @@

              ["inv-dsh-ucs" #(hes/dsh-ucs-inverted h8i)]

-             ["dash-a*" #(da/implicit-dash-a* h8i)]
+             #_ ["dash-a*" #(da/implicit-dash-a* h8i)]
              #_ ["explicit-ah-a*" #(hes/explicit-simple-ah-a* h1)]
              ]]
       (println (pad-right n 20)


leave: subject is animate

leave: subject is animate

--- src/babel/english/lexicon.cljc
+++ src/babel/english/lexicon.cljc
@@ -1092,12 +1092,14 @@
    "leave" [{:english {:past "left"}
              :synsem {:cat :verb
                       :sem {:pred :leave-behind
+                            :subj {:animate true}
                             :obj {:place false}}}}

             {:english {:note "on a trip"
                        :past "left"}
              :synsem {:cat :verb
-                      :sem {:pred :leave}}}]
+                      :sem {:pred :leave
+                            :subj {:animate true}}}}]

    "lie" {:synsem {:cat :verb
                    :sem {:pred :lie}}}


+put {on,off,up-with}

+put {on,off,up-with}

--- src/babel/english/lexicon.cljc
+++ src/babel/english/lexicon.cljc
@@ -3,7 +3,7 @@
   (:require
    [babel.encyclopedia :as encyc]
    [babel.english.morphology :as morph]
-   [babel.lexiconfn :refer [compile-lex default new-entries verb-pred-defaults]]
+   [babel.lexiconfn :refer [apply-unify-key compile-lex default new-entries verb-pred-defaults]]
    [dag_unify.core :refer [dissoc-paths fail? get-in strip-refs unify]]))

 (def lexicon-source
@@ -1641,12 +1641,45 @@
                            ;; example of a synonym, where we use the convention of making the
                            ;; :pred (i.e. :student) the more common case (c.f. "student")
                            :pred :student}}}
-
-   "put" {:english {:past "put"
-                    :participle "putting"}
-          :synsem {:cat :verb
-                   :sem {:pred :put}}}
-
+   "put"
+   (let [common {:english {:participle "putting"
+                           :past "put"
+                           :present {:3sing "put"}
+                           :note "past tense"}}]
+     [{:unify [common]
+       :phrasal-verb true
+       :synsem {:cat :verb
+                :sem {:pred :insult}
+                :subcat {:2 {:cat :prep
+                             :sem {:pred :down}}}}}
+      {:unify [common]
+       :phrasal-verb true
+       :synsem {:cat :verb
+                :sem {:pred :delay}
+                :subcat {:2 {:cat :prep
+                             :sem {:pred :off}}}}}
+      {:unify [common]
+       :phrasal-verb true
+       :synsem {:cat :verb
+                :sem {:pred :put-on}
+                :subcat {:2 {:cat :prep
+                             :sem {:pred :on}}}}}
+      {:unify [common]
+       :phrasal-verb true
+       :synsem {:cat :verb
+                :sem {:pred :tolerate}
+                :subcat {:2 {:cat :prep
+                             :sem {:pred :up-with}}}}}])
+   "put on"
+   {:english {:participle "putting on"
+              :past "put on"
+              :present {:3sing "puts on"}
+              :note "past tense"}
+    :phrasal-verb true
+    :intransitivize false
+    :synsem {:cat :verb
+             :sem {:pred :put-on}}}
+
    "radio" {:synsem {:cat :noun
                      :sem {:pred :radio}}}

@@ -2516,6 +2549,8 @@
                    morph/exception-generator
                    morph/phonize)

+      apply-unify-key
+
       ;; <category-independent rules>

       (default


Add comment to wpml/make-resource

Add comment to wpml/make-resource

--- src/bakyeono/litedocx/wpml.clj
+++ src/bakyeono/litedocx/wpml.clj
@@ -177,6 +177,7 @@
    :target "styles.xml"})

 (defn- content-type->relationship-type
+  "Called by make-resource"
   [content-type]
   (str xmlns-r "/" (re-find #"[\w]*" content-type)))


Add path selection component when path is in edition mode.

--- src/uxbox/main/ui/workspace/selection.cljs
+++ src/uxbox/main/ui/workspace/selection.cljs
@@ -93,6 +93,23 @@
                   :style {:stroke "#333" :fill "transparent"
                           :stroke-opacity "1"}}]]))

+(mx/defc path-edition-selection-handlers
+  [{:keys [id points] :as shape}]
+  (letfn [(on-mouse-down [index event]
+            (dom/stop-propagation event)
+            (rlocks/acquire! :shape/resize)
+            (println "on-mouse-down" index)
+            (start-path-edition id index))
+
+            #_(rlocks/acquire! :shape/resize [vid id])]
+    (let [tmx (geom/transformation-matrix shape)
+          points (map #(gpt/transform % tmx) points)]
+      [:g.controls
+       (for [[index {:keys [x y]}] (map-indexed vector points)]
+         [:circle {:cx x :cy y :r 3
+                   :on-mouse-down (partial on-mouse-down index)
+                   :fill "red"}])])))
+
 (mx/defc single-selection-handlers
   [{:keys [id] :as shape}]
   (letfn [(on-mouse-down [vid event]
@@ -158,4 +175,8 @@
       (> shapes-num 1)
       (multiple-selection-handlers shapes)

+      (and (= :path (:type shape))
+           (:edition? shape))
+      (path-edition-selection-handlers shape)
+
       (= shapes-num 1) (single-selection-handlers (first shapes)))))


add name checking and warning field

add name checking and warning field

--- src/cljs/schafkopfen/core.cljs
+++ src/cljs/schafkopfen/core.cljs
@@ -29,7 +29,8 @@
   (reify
     om/IInitState
     (init-state [_]
-      {:delete (chan)})
+      {:delete (chan)
+       :warning nil})
     om/IWillMount
     (will-mount [_]
       (let [delete (om/get-state owner :delete)]
@@ -39,18 +40,24 @@
                           (fn [xs] (vec (remove #(= player %) xs))))
             (recur)))))
     om/IRenderState
-    (render-state [this {:keys [delete]}]
-      (let [on-name-submit (fn [e]
-                             (let [input (om/get-node owner "new-player-name")
-                                   name (-> input .-value)]
-                               (when name
-                                 (om/transact! data :players #(conj % {:name name}))
-                                 (set! (.-value input) "")))
-                             false)]
+    (render-state [this {:keys [delete warning]}]
+      (let [on-name-submit
+            (fn [e]
+              (let [input (om/get-node owner "new-player-name")
+                    name (-> input .-value)]
+                (cond
+                  (or (not name) (= "" name)) (om/set-state! owner :warning "Invalid name!")
+                  (some #(= name (:name %)) (:players data)) (om/set-state! owner :warning "Duplicate user!")
+                  :default (do
+                             (om/transact! data :players #(conj % {:name name}))
+                             (set! (.-value input) "")
+                             (om/set-state! owner :warning nil))))
+              false)]
         (dom/div nil
                  (dom/h2 nil "Players")
                  (apply dom/ul nil
                         (om/build-all player-view (:players data) {:init-state {:delete delete}}))
+                 (when-not (nil? warning) (dom/div #js {:className "alert alert-danger" :role "alert"} warning))
                  (dom/form #js {:onSubmit on-name-submit}
                            (dom/input #js {:type :text :placeholder "Name" :ref "new-player-name"})
                            (dom/button


Have working diff algorithm in this commit - but! in my tests in Firefox and Chrome, DOM replacing outperforms diff updating - maybe the algorithm can be optimized, but probably because I am using Clojure data structure as the virtual DOM, this causes a big hit and possibly also the fact that reactive computations need to be stopped. For now, diffing will stay off.

--- src/clojure/freactive/dom.cljs
+++ src/clojure/freactive/dom.cljs
@@ -230,13 +230,17 @@

 ;; ## Attributes, Styles & Events

+(defn- set-attr! [elem attr-name attr-value]
+  (.setAttribute elem attr-name attr-value))
+
+(defn- remove-attr! [elem attr-name]
+  (.removeAttribute elem attr-name))
+
 (defn- set-style-prop! [elem prop-name prop-value]
-  (let [prop-name (name prop-name)]
-    (aset (.-style elem) prop-name (str prop-value))))
-
-(defn- set-attr! [elem attr-name attr-value]
-  (let [attr-name (name attr-name)]
-    (.setAttribute elem attr-name attr-value)))
+  (aset (.-style elem) prop-name (str prop-value)))
+
+(defn- remove-style-prop! [elem prop-name]
+  (js-delete (.-style elem) prop-name))

 (defn- on-value-ref-invalidated* [set-fn element state-prefix attr-name ref node-state]
   (when-let [[add-watch* remove-watch*] (r/get-add-remove-watch* ref)]
@@ -248,35 +252,29 @@
               ([key ref _ _]
                (on-value-ref-invalidated key ref))
               ([key ref]
-               ;(set-fn element attr-name @ref)
                (remove-watch* ref key)
                (queue-animation
                  (fn [_]
                    (when-not (.-disposed attr-state)
                      (add-watch* ref key on-value-ref-invalidated)
-                     (set-fn element attr-name (non-reactively @ref)))
-                   ))
-               ;(when (.-parentNode element)
-               ;  (add-watch* ref key on-value-ref-invalidated)
-               ;  (set-fn element attr-name @ref))
-               ))]
-      ;;(set! (.-invalidate attr-state) f)
-      (register-with-parent-state node-state (str "-" state-prefix "."
-                                                  attr-name) attr-state)
-      ;(set! (.-child-states node-state)
-      ;      (assoc (.-child-states node-state)
-      ;                                        attr-state))
-      (add-watch* ref key f)
-      ))
-  (set-fn element attr-name @ref))
-
-(defn bind-style-prop! [element attr-name attr-value node-state]
-  (if (satisfies? cljs.core/IDeref attr-value)
-    (on-value-ref-invalidated* set-style-prop! element "style" attr-name attr-value node-state)
-    (set-style-prop! element attr-name attr-value)))
+                     (set-fn (non-reactively @ref)))))))]
+      (register-with-parent-state node-state
+                                  (str "-" state-prefix "." attr-name) attr-state)
+      (add-watch* ref key f)))
+
+  (set-fn @ref))
+
+(defn- bind-style-prop! [element attr-name attr-value node-state]
+  (let [setter (fn [v] (set-style-prop! element attr-name attr-value))]
+    (if (satisfies? cljs.core/IDeref attr-value)
+      (on-value-ref-invalidated* setter element "style" attr-name attr-value node-state)
+      (setter attr-value))))

 (defn listen! [element evt-name handler]
   (.addEventListener element evt-name handler))
+
+(defn remove-event-listener! [element evt-name handler]
+  (.removeEventListener element evt-name handler))

 (defn- do-set-data-state! [element state]
   (set-attr! element "data-state" state))
@@ -289,7 +287,6 @@
     (enter-transition element old-state)))

 (defn set-data-state!
-  ([element _ state] (set-data-state! element state))
   ([element state]
     (let [cur-state (get-data-state element)
           state (name state)]
@@ -304,96 +301,131 @@
   (if (satisfies? cljs.core/IDeref attr-value)
         (on-value-ref-invalidated* set-fn element "attr" attr-name
                                    attr-value node-state)
-        (set-fn element attr-name attr-value)))
-
-(defn get-attr-setter [element attr-name]
+        (set-fn attr-value)))
+
+(defn- bind-event-listener! [element event-name handler node-state]
+  (let [attr-state #js {:disposed false :handler handler
+                        :disposed-callback (fn [] (remove-event-listener!
+                                                    element event-name
+                                                    handler))}]
+      (register-with-parent-state node-state (str "-" "event" "." event-name) attr-state)
+      (listen! element event-name handler)))
+
+(defn- bind-style! [element styles node-state]
+  (doseq [[p v] styles]
+    (bind-style-prop! element (name p) v node-state)))
+
+(defn- get-attr-setter [element attr-name]
   (cond
-   (identical? "data-state" attr-name)
-   set-data-state!
-
-   (and (identical? (. element -type) "checkbox") (identical? attr-name "checked"))
-   (fn [node attr-name attr-value]
-     (set! (. node -checked) (true? attr-value)))
-
-   :default
-   set-attr!))
-
-(defn bind-attr! [element attr-name attr-value node-state]
+    (identical? "data-state" attr-name)
+    (fn [state] (set-data-state! element state))
+
+    (and (identical? (. element -type) "checkbox") (identical? attr-name "checked"))
+    (fn [attr-value]
+      (set! (. element -checked) (true? attr-value)))
+
+    (identical? "id" attr-name)
+    (fn [id] (set! (.-id element) id))
+
+    (identical? "class" attr-name)
+    (fn [cls] (set! (.-className element) cls))
+
+    :default
+    (fn [attr-value] (.setAttribute element attr-name attr-value))))
+
+(defn- bind-attr! [element attr-name attr-value node-state]
   (let [attr-name (name attr-name)]
     (cond
       (identical? "style" attr-name)
-      (do
-        (assert (map? attr-value))
-        (doseq [[p v] attr-value]
-          (bind-style-prop! element p v node-state)))
+      (bind-style! element attr-value node-state)

       (identical? 0 (.indexOf attr-name "on-"))
-      (listen! element (.substring attr-name 3) attr-value)
+      (bind-event-listener! element (.substring attr-name 3) attr-value node-state)

       :default
       (bind-prop-attr! (get-attr-setter element attr-name)
                        element attr-name attr-value node-state))))

+(defn- dispose-child-state [node-state child-key]
+  (when-let [child-states (.-child-states node-state)]
+      (when-let [state (aget child-states child-key)]
+        (set! (.-disposed state) true)
+        (when-let [disposed-callback (.-disposed-callback state)]
+          (disposed-callback))
+        (js-delete child-states child-key))))
+
 (defn- unbind-attr!* [node-state prefix attr-name]
   (let [attr-key (str "-" prefix "." attr-name)]
-    (when-let [child-states (.-child-states node-state)]
-      (when-let [state (aget child-states attr-key)]
-        (set! (.-disposed state) true)
-        (js-delete child-states attr-key)))))
-
-(defn- rebind-style! [element attr-name styles node-state]
+    (dispose-child-state node-state attr-key)))
+
+(defn- rebind-style-prop! [element style-name style-value node-state]
+  (unbind-attr!* node-state "style" style-name)
+  (if style-value
+    (bind-style-prop! element style-name style-value node-state)
+    (remove-style-prop! element style-name)))
+
+(defn- rebind-style! [element styles node-state]
   (doseq [[p v] styles]
-    (unbind-attr!* node-state "style" attr-name)
-    (bind-style-prop! element p v node-state)))
+    (rebind-style-prop! element (name p) v node-state)))
+
+(defn- rebind-event! [element event-name handler node-state]
+  (unbind-attr!* node-state "event" event-name)
+  (when handler
+    (listen! element event-name handler)))
+
+(defn- rebind-prop-attr! [element attr-name attr-value node-state]
+  (unbind-attr!* node-state "attr" attr-name)
+  (if attr-value
+    (bind-attr! element attr-name attr-value node-state)
+    (remove-attr! element attr-name)))

 (defn- rebind-attr! [element attr-name attr-value node-state]
-  )
+  (cond
+      (identical? "style" attr-name)
+      (rebind-style! element attr-value node-state)
+
+      (identical? 0 (.indexOf attr-name "on-"))
+      (rebind-event! element (.substring attr-name 3) attr-value node-state)
+
+      :default
+      (rebind-prop-attr! element attr-name attr-value node-state)))

 (defn set-attrs! [node attrs]
   (let [node-state (get-element-state node)]
     (doseq [[k v] attrs]
       (let [k (name k)]
-        (if (identical? k "style")
-          (doseq [[p v] v]
-            (do
-              (when node-state
-                (unbind-attr!* node-state "style" p))
-              (bind-style-prop! node p v node-state)))
-          (do
-            (when node-state
-              (unbind-attr!* node-state "attr" k))
-            (bind-attr! node k v node-state)))))))
-
-;(defn- replace-attr!* [node node-state attr-name old-val new-val prefix binder]
-;  (if (not (identical? old-val new-val))
-;    (unbind-attr!* node-state prefix attr-name)
-;    (binder node attr-name new-val node-state)))
-;
-;(defn- replace-attr! [node node-state attr-name old-val new-val]
-;  (replace-attr!* node node-state attr-name old-val new-val "attr"))
-
-(defn- replace-attrs!* [node node-state old-attrs new-attrs rebinder binder
-                        remover]
+        (rebind-attr! node k v node-state)))))
+
+(defn- replace-attrs!* [node node-state old-attrs new-attrs rebinder]
   (loop [[[k new-val] & new-attrs] (seq new-attrs)
          old-attrs old-attrs]
     (if k
       (let [attr-name (name k)]
         (if-let [existing (get old-attrs k)]
           (do
-            (rebinder node node-state attr-name existing new-val)
+            (when-not (identical? existing new-val)
+              (rebinder node attr-name new-val node-state))
             (recur new-attrs (dissoc old-attrs k)))
           (do
-            (binder node node-state attr-name new-val)
+            (rebinder node attr-name new-val node-state)
             (recur new-attrs old-attrs))))
-      (loop [[[k v] & old-attrs] old-attrs]
+      (loop [[[k v] & old-attrs] (seq old-attrs)]
         (when k
-          (remover node node-state (name k))
+          (rebinder node (name k) nil node-state)
           (recur old-attrs))))))

 (defn- replace-attrs! [node old-attrs new-attrs]
-  (let [node-state (get-element-state node)]
-    ;;(replace-attrs!* node node-state old-attrs new-attrs nil nil )
-    ))
+  (let [node-state (get-element-state node)
+        old-style (:style old-attrs)
+        new-style (:style new-attrs)]
+    (replace-attrs!* node node-state
+                     (dissoc old-attrs :style)
+                     (dissoc new-attrs :style)
+                     rebind-attr!)
+    (replace-attrs!* node node-state
+                     old-style
+                     new-style
+                     rebind-style-prop!)))

 ;; From hiccup.compiler:
 (def ^{:doc "Regular expression that parses a CSS-style id and class from an element name."
@@ -420,6 +452,17 @@
     (when class (set! (.-className node) (.replace class "." " ")))
     node))

+(defn- create-dom-node-simple [tag]
+  (let [tag-ns (namespace tag)
+        node (if tag-ns
+               (let [resolved-ns
+                     (if (identical? tag-ns "svg")
+                       "http://www.w3.org/2000/svg"
+                       (get-xml-namespace tag-ns))]
+                 (.createElementNS js/document resolved-ns tag))
+               (.createElement js/document tag))]
+    node))
+
 ;; ## Core DOM Manipulation Methods

 (declare build-element)
@@ -427,26 +470,98 @@
 (defn- text-node? [dom-node]
   (identical? (.-nodeType dom-node) 3))

-(defn- replace-child [parent new-elem-spec cur-elem]
-  (let [cur-dom-node cur-elem                                       ;;
-  ;; (get-dom-node cur-elem)
-        new-virtual-dom (get-virtual-dom new-elem-spec)]
-    (if (and
-          (string? new-virtual-dom)
-          (text-node? cur-dom-node))
+(def enable-diffing false)
+
+(defn- can-diff-element [parent new-elem-spec cur-elem])
+
+(defn- normalize-virtual-element [dom-vec]
+  (let [tag (first dom-vec)
+        tag-ns (namespace tag)
+        [_ tag id class] (re-matches re-tag (name tag))
+        class (when class (.replace class "." " "))
+        attrs? (second dom-vec)
+        attrs (when (map? attrs?) attrs?)
+        children (if attrs (nnext dom-vec) (next dom-vec))]
+    (if (or id class)
+      (into [(keyword tag-ns tag) (merge attrs {:id id :class class})]
+            children)
+      dom-vec)))
+
+(defn- replace-node-completly [parent new-elem-spec cur-dom-node]
+  (let [new-elem (build-element new-elem-spec)]
+        (.replaceChild parent new-elem cur-dom-node)
+        (dispose-node cur-dom-node)
+        new-elem))
+
+(declare replace-child)
+
+(declare replace-or-append-child)
+
+(declare append-children!)
+
+(defn- try-diff-subseq [parent cur-child new-children]
+  (loop [cur-child cur-child
+         new-child (first new-children)
+         more (rest new-children)]
+    (if new-child
+      (if cur-child
+        (if (and (sequential? new-child) (not (keyword? (first new-child))))
+          (let [cur-child (try-diff-subseq parent cur-child new-child)]
+            (recur cur-child (first more) (rest more)))
+          (do
+            (replace-child parent new-child cur-child false)
+            (recur (.-nextSibling cur-child) (first more) (rest more))))
+        (do
+          (append-children! parent new-children)
+          nil))
+      cur-child)))
+
+(defn- try-diff [parent vdom cur-dom-node top-level]
+  (let [cur-vdom (get-virtual-dom cur-dom-node)
+        vdom (normalize-virtual-element vdom)]
+    (if (keyword-identical? (first vdom) (first cur-vdom))
+      (let [old-attrs? (second cur-vdom)
+            new-attrs? (second vdom)
+            new-attrs (when (map? new-attrs?) new-attrs?)]
+        (replace-attrs! cur-dom-node
+                        (when (map? old-attrs?) old-attrs?)
+                        new-attrs)
+        (when-not top-level
+          (dispose-child-state (get-element-state cur-dom-node) "-reactive"))
+        (reset-element-spec! cur-dom-node vdom)
+        (let [new-children (if new-attrs (nnext vdom) (next vdom))
+              dangling-child (try-diff-subseq cur-dom-node (.-firstChild cur-dom-node) new-children)]
+          (loop [cur-child dangling-child]
+            (when cur-child
+              (let [next-sib (.-nextSibling cur-child)]
+                (.removeChild cur-dom-node cur-child)
+                (recur next-sib)))))
+        cur-dom-node)
+      (replace-node-completly parent vdom cur-dom-node))))
+
+(defn- replace-child [parent new-elem-spec cur-dom-node top-level]
+  (let [new-virtual-dom (get-virtual-dom new-elem-spec)]
+    (if
+      (and (string? new-virtual-dom)
+           (text-node? cur-dom-node))
       (do
         (set! (.-textContent cur-dom-node) new-virtual-dom)
-        ;(reset-element-spec! cur-dom-node new-elem-spec)
-        cur-elem)
-      (let [new-elem (build-element new-elem-spec)]
-        (.replaceChild
-          ;(get-dom-node parent)
-          ;(get-dom-node new-elem)
-          parent
-          new-elem
-          cur-dom-node)
-        (dispose-node cur-dom-node)
-        new-elem))))
+        cur-dom-node)
+
+      (if enable-diffing
+        (if top-level
+          (do
+            (println "starting diff replace")
+            (time
+              (try-diff parent new-virtual-dom cur-dom-node top-level)))
+          (try-diff parent new-virtual-dom cur-dom-node top-level))
+
+        (if top-level
+          (do
+            (println "starting full replace")
+            (time
+              (replace-node-completly parent new-elem-spec cur-dom-node))))
+        (replace-node-completly parent new-elem-spec cur-dom-node)))))

 (defn- append-child [parent new-elem]
   (let [new-elem (build-element new-elem)]
@@ -456,10 +571,10 @@
       new-elem)
     new-elem))

-(defn- replace-or-append-child [parent new-elem cur-elem]
+(defn- replace-or-append-child [parent new-elem cur-elem top-level]
   (let [new-elem
         (if cur-elem
-          (replace-child parent new-elem cur-elem)
+          (replace-child parent new-elem cur-elem top-level)
           (append-child parent new-elem))]
     (when-not (text-node? new-elem)
       (when-let [parent-state (get-element-state parent)]
@@ -471,7 +586,7 @@
 (defn- do-show-element [parent new-elem cur-elem]
   (when new-elem
     (let [show (get-transition new-elem :node-attached)
-          new-elem (replace-or-append-child parent new-elem cur-elem)]
+          new-elem (replace-or-append-child parent new-elem cur-elem true)]
       (when show
         (show new-elem)
         new-elem)
@@ -508,12 +623,12 @@

 ;; Reactive Element Handling

-(def ^:private auto-reactive-id 0)
-
-(defn- new-reactive-id []
-  (let [id auto-reactive-id]
-    (set! auto-reactive-id (inc auto-reactive-id))
-    (str "-r." id)))
+;(def ^:private auto-reactive-id 0)
+;
+;(defn- new-reactive-id []
+;  (let [id auto-reactive-id]
+;    (set! auto-reactive-id (inc auto-reactive-id))
+;    (str "-r." id)))

 (deftype ReactiveElement [id parent cur-element dirty updating disposed animate invalidate]
   IRemove
@@ -526,8 +641,7 @@

 (defn- append-deref-child [parent child-ref]
   (if-let [[add-watch* remove-watch*] (r/get-add-remove-watch* child-ref)]
-    (let [reactive-id (new-reactive-id)
-          state (ReactiveElement. reactive-id parent nil false false false nil  nil)
+    (let [state (ReactiveElement. nil parent nil false false false nil  nil)

           get-new-elem (fn []
                          (set! (.-dirty state) false)
@@ -535,7 +649,7 @@
                          (or (non-reactively @child-ref) ""))

           show-new-elem (fn [new-elem cur]
-                          (let [new-node (replace-or-append-child parent new-elem cur)]
+                          (let [new-node (replace-or-append-child parent new-elem cur true)]
                             (set! (.-cur-element state) new-node)
                             (set! (.-updating state) false)
                             (when (.-dirty state)
@@ -585,7 +699,7 @@
       ;(set! (.-cur-element state)
       ;      (transition-element parent (or (non-reactively @child-ref) [:span]) nil))
       (when-let [parent-state (get-element-state parent)]
-        (register-with-parent-state parent-state reactive-id state))
+        (register-with-parent-state parent-state "-reactive" state))
       state)
     (transition-element parent @child-ref nil)))

@@ -611,10 +725,9 @@
   (let [virtual-dom (get-virtual-dom elem-spec)
         node
         (if (string? virtual-dom)
-          (let [node (.createTextNode js/document virtual-dom)]
-            ;(init-element-state! node elem-spec)
-            node)
-          (let [node (create-dom-node (first virtual-dom))
+          (.createTextNode js/document virtual-dom)
+          (let [virtual-dom (normalize-virtual-element virtual-dom)
+                node (create-dom-node (first virtual-dom))
                 state (init-element-state! node elem-spec)
                 attrs? (second virtual-dom)
                 attrs (when (map? attrs?) attrs?)


Changing the search algorithm a bit.

Changing the search algorithm a bit.

- Sorting by levenshtein first, before soundex.
- Sorting by levenshtein should be ascending, not descending.

--- src/movertone/db.clj
+++ src/movertone/db.clj
@@ -27,7 +27,7 @@
            levenshtein (?, name) AS lev_diff
            FROM ragams
            WHERE name % ? AND similarity (name, ?) > ?
-           ORDER BY soundex_diff desc, lev_diff desc"]
+           ORDER BY lev_diff, soundex_diff desc"]
     (j/query db-spec [q ragam ragam ragam ragam perc])))

 ;; setup DB


add push-down-indents func

add push-down-indents func

--- saas-dsl/src/saas_dsl/parse.clj
+++ saas-dsl/src/saas_dsl/parse.clj
@@ -30,3 +30,22 @@
   {:pre [(not (nil? loc))]}
   (if (zip/left loc)
     (zip/branch? (zip/left loc))))
+
+(defn push-down-indents
+  "Given a particular location in the tree - turn leading spaces into three nodes."
+  [loc]
+  (if (zip/end? loc)
+    (zip/root loc)
+    (if (has-indent loc)
+      (let [reduced-indent-node (drop-one-indent (zip/node loc))]
+        (if (is-left-branch loc)
+          (recur (-> loc
+                     zip/left
+                     (zip-arround-child  reduced-indent-node)
+                     zip/right
+                     zip/remove))
+          (recur (-> loc
+                     (zip/insert-letf [])
+                     zip/remove
+                     (zip/append-child reduced-indent-node)))))
+      (recur (zip/next loc)))))


eh, 0.2.0

eh, 0.2.0

--- plugin/project.clj
+++ plugin/project.clj
@@ -1,4 +1,4 @@
-(defproject io.nervous/lein-cljs-lambda "0.1.3-SNAPSHOT"
+(defproject io.nervous/lein-cljs-lambda "0.2.0-SNAPSHOT"
   :description "Deploying Clojurescript functions to AWS Lambda"
   :url "https://github.com/nervous-systems/cljs-lambda"
   :license {:name "Unlicense" :url "http://unlicense.org/UNLICENSE"}


version bump

version bump

--- project.clj
+++ project.clj
@@ -1,7 +1,7 @@
 (def shared '[[com.esotericsoftware.kryo/kryo "2.16"]
               [com.twitter/meat-locker "0.3.0"]])

-(defproject cascalog/carbonite "1.3.0-SNAPSHOT"
+(defproject cascalog/carbonite "1.3.0"
   :source-path "src/clj"
   :java-source-path "src/jvm"
   :description "Write Clojure data to and from bytes using Kryo."


lein-release plugin: bumped version from 0.3.3 to 0.3.4-SNAPSHOT for next development cycle

--- project.clj
+++ project.clj
@@ -1,7 +1,7 @@
 (def tk-version "0.3.3")
 (def ks-version "0.5.2")

-(defproject puppetlabs/trapperkeeper-webserver-jetty9 "0.3.3"
+(defproject puppetlabs/trapperkeeper-webserver-jetty9 "0.3.4-SNAPSHOT"
   :description "We are trapperkeeper.  We are one."
   ;; Abort when version ranges or version conflicts are detected in
   ;; dependencies. Also supports :warn to simply emit warnings.


bumps the version number

bumps the version number

--- project.clj
+++ project.clj
@@ -1,4 +1,4 @@
-(defproject ring-curl "0.1.3"
+(defproject ring-curl "0.1.4"
             :description "Converts ring requests to cURL commands"
             :url "https://github.com/GentlemanHal/ring-curl"
             :license {:name "Eclipse Public License"


org.clojure/test.check 0.8.0-alpha3 released

--- project.clj
+++ project.clj
@@ -43,7 +43,7 @@
   :main ^:skip-aot icecap.core
   :target-path "target/%s"
   :profiles {:uberjar {:aot :all}
-             :dev {:dependencies [[org.clojure/test.check "0.8.0-alpha2"]]
+             :dev {:dependencies [[org.clojure/test.check "0.8.0-alpha3"]]
                    :aliases ^:replace {"lint"
                                        ["do"
                                         ["clean"]


Update dependencies.

Update dependencies.

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

   :dependencies [
     ;; Server-side
-    [org.clojure/clojure "1.8.0-RC4"] ; Lisp on the JVM http://clojure.org/documentation
+    [org.clojure/clojure "1.8.0-RC5"] ; Lisp on the JVM http://clojure.org/documentation
     [org.clojure/core.match "0.3.0-alpha4"] ; Erlang-esque pattern matching https://github.com/clojure/core.match
     [defun "0.3.0-alapha"] ; Erlang-esque pattern matching for Clojure functions https://github.com/killme2008/defun
     [org.clojure/core.incubator "0.1.3"] ; Functions proposed for inclusion in Clojure https://github.com/clojure/core.incubator
@@ -26,7 +26,7 @@
     [compojure "1.4.0"] ; Web routing https://github.com/weavejester/compojure
     [liberator "0.14.0"] ; WebMachine (REST API server) port to Clojure https://github.com/clojure-liberator/liberator
     [com.ashafa/clutch "0.4.0"] ; CouchDB client https://github.com/clojure-clutch/clutch
-    [clojurewerkz/elastisch "2.2.0-rc1"] ; Client for ElasticSearch https://github.com/clojurewerkz/elastisch
+    [clojurewerkz/elastisch "2.2.1"] ; Client for ElasticSearch https://github.com/clojurewerkz/elastisch
     [environ "1.0.1"] ; Get environment settings from different sources https://github.com/weavejester/environ
     [com.taoensso/timbre "4.2.0"] ; Logging https://github.com/ptaoussanis/timbre
     [clj-http "2.0.0"] ; HTTP client https://github.com/dakrone/clj-http


Update mistakes-were-made

Update mistakes-were-made

--- project.clj
+++ project.clj
@@ -18,7 +18,7 @@
                  [lein-droid "0.4.3"]
                  [lein-typed "0.3.5"]
                  [lein-ring "0.9.7"]
-                 [mistakes-were-made "1.0.0-SNAPSHOT"]
+                 [mistakes-were-made "1.0.0"]
                  [net.cgrand/parsley "0.9.3"
                   :exclusions [org.clojure/clojure]]
                  [net.java.balloontip/balloontip "1.2.4.1"]


remove stray chars

remove stray chars

--- project.clj
+++ project.clj
@@ -61,4 +61,3 @@
   :jvm-opts ^:replace ["-server" "-Xmx2g"]
   :global-vars {*warn-on-reflection* false}
   :min-lein-version "2.5.0")
-eans


add friend-oauth2

add friend-oauth2

--- project.clj
+++ project.clj
@@ -12,6 +12,7 @@
                  [com.taoensso/carmine "2.6.2"]
                  [com.cemerick/friend "0.2.1"
                   :exclusions [org.apache.httpcomponents/httpclient]]
+                 [friend-oauth2 "0.1.1"]
                  [k2nr/docker "0.0.3-SNAPSHOT"]
                  [ring "1.2.2"]]
   :profiles {:dev {:dependencies [[midje "1.6.3"]


Update to Immutant 2.1.3.

Update to Immutant 2.1.3.

--- project.clj
+++ project.clj
@@ -4,7 +4,7 @@
   :license {:name "Eclipse Public License"
             :url "http://www.eclipse.org/legal/epl-v10.html"}
   :dependencies [[org.clojure/clojure "1.7.0"]
-                 [org.immutant/immutant "2.x.incremental.706"]
+                 [org.immutant/immutant "2.1.3"]
                  [compojure "1.4.0"]
                  [ring/ring-devel "1.3.1"]
                  [org.clojure/core.memoize "0.5.6"]


Replace algo.monads with cats.

Replace algo.monads with cats.

--- project.clj
+++ project.clj
@@ -4,9 +4,9 @@
   :license {:name "BSD (2-Clause)"
             :url "http://opensource.org/licenses/BSD-2-Clause"}
   :dependencies [[org.clojure/clojure "1.6.0"]
+                 [com.taoensso/nippy "2.7.1"]
                  [buddy/buddy-core "0.3.0"]
-                 [org.clojure/algo.monads "0.1.5"]
-                 [com.taoensso/nippy "2.7.1"]
+                 [cats "0.2.0"]
                  [clj-time "0.9.0"]
                  [cheshire "5.4.0"]]
   :source-paths ["src/clojure"]


Trying to fix build error on Travis-CI.

Trying to fix build error on Travis-CI.

--- project.clj
+++ project.clj
@@ -40,7 +40,7 @@
     :security {
       :plugins [
         [lein-nvd "0.5.4"]]
-        :source-paths ^:replace ["src"]
+      :source-paths ^:replace ["src"]
       :nvd {
         :suppression-file "resources/security/false-positives.xml"}
       :exclusions [
@@ -49,9 +49,11 @@
         [com.google.javascript/closure-compiler-unshaded]
         [commons-fileupload]]
       :dependencies [
-        ;; The following pull required deps that have been excluded above due
-        ;; to CVEs
-        [commons-fileupload "1.3.3"]]}
+        ;; The following pull required deps that have been either been
+        ;; explicitly or implicitly excluded above due to CVEs and need
+        ;; declare secure versions of the libs pulled in
+        [commons-fileupload "1.3.3"]
+        [commons-io "2.5"]]}
     :dev {
       :dependencies [
         [clojusc/system-manager "0.3.0-SNAPSHOT"]


enabled 'lein run'

enabled 'lein run'

--- project.clj
+++ project.clj
@@ -2,6 +2,8 @@
   :dependencies [[org.clojure/clojure "1.5.1"]]
   :profiles {:dev {:dependencies [[midje "1.5.1"]]
                    :plugins [[lein-midje "3.1.1"]]}}
+  :resource-paths ["./LeapSDK/lib/LeapJava.jar"]
+  :jvm-opts ["-Djava.library.path=./LeapSDK/lib"]
   :main ^:skip-aot sormilla.main
   :repl-options {:init-ns sormilla.main}
   :min-lein-version "2.0.0")


Change name of generated uberjar to statuses.jar

Makes deployment easier and there is not much information in keeping the
version number and the standalone part.

--- project.clj
+++ project.clj
@@ -17,5 +17,6 @@
              :uberjar {:aot [statuses.server]}}
   :main statuses.server
   :aliases {"lint" "eastwood"}
+  :uberjar-name "statuses.jar"
   :eastwood {:exclude-linters [:constant-test]})


adding the lein-figwheel plugin with a figwheel configuration map

--- project.clj
+++ project.clj
@@ -25,8 +25,16 @@
   :plugins [[lein-environ "1.0.0"]
             [lein-ring "0.8.11"]
             [codox "0.8.13"]
-            [lein-cljsbuild "1.1.0"]]
+            [lein-cljsbuild "1.1.0"]
+            [lein-figwheel "0.4.0"]]
   :clean-targets ^{:protect false} ["resources/public/js" "target"]
+  :figwheel {
+             ;; :http-server-root "public" ;; default and assumes "resources"
+             ;; :server-port 3449 ;; default
+             ;; :server-ip "127.0.0.1"
+
+             :css-dirs ["resources/public/css"] ;; watch and update CSS
+             }
   :cljsbuild {:builds {:app {:source-paths ["src-cljs"]
   :clean-targets ^{:protect false} ["resources/public/js/compiled" "target"]
                              :compiler {:output-to     "resources/public/js/app.js"


Release 0.9.2

Release 0.9.2

--- project.clj
+++ project.clj
@@ -1,5 +1,5 @@
 (defproject
-  fleet "0.9.2-SNAPSHOT"
+  fleet "0.9.2"
   :description "Templating System for Clojure"
   :url "http://github.com/Flamefork/fleet"


release 3.0.4

release 3.0.4

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


Upgrade nippy

Upgrade nippy

--- project.clj
+++ project.clj
@@ -9,7 +9,7 @@
                  [com.novemberain/welle "3.0.0"]

                  ;; Serialization
-                 [com.taoensso/nippy "2.11.0-alpha6"
+                 [com.taoensso/nippy "2.11.1"
                   :exclusions [org.clojure/clojure com.taoensso/encore]]

                  ;; Handlers


Update dependency.

Update dependency.

--- project.clj
+++ project.clj
@@ -21,7 +21,7 @@
                  [com.climate/claypoole "1.0.0"]
                  [org.clojars.brunchboy/protobuf "0.8.3"]
                  [ola-clojure "0.1.0"]
-                 [selmer "0.8.8"]
+                 [selmer "0.8.9"]
                  [com.evocomputing/colors "1.0.2"]
                  [environ "1.0.0"]
                  [com.taoensso/timbre "4.1.0"]


new version

new version

--- project.clj
+++ project.clj
@@ -1,4 +1,4 @@
-(defproject corpus-utils "0.0.4.2"
+(defproject corpus-utils "0.0.5"
   :description "Miscellaneous utilities to parse Japanese language corpora with Clojure"
   :url "https://github.com/borh/corpus-utils.git"
   :license {:name "Eclipse Public License"


bump to 1.1.1-SNAPSHOT.

bump to 1.1.1-SNAPSHOT.

--- project.clj
+++ project.clj
@@ -1,4 +1,4 @@
-(defproject backtype/dfs-datastores-cascading "1.1.0"
+(defproject backtype/dfs-datastores-cascading "1.1.1-SNAPSHOT"
   :java-source-path "src/jvm"
   :source-path "src/clj"
   :java-test-path "test/jvm"


Version 0.1.0

Version 0.1.0

--- project.clj
+++ project.clj
@@ -1,4 +1,4 @@
-(defproject stl-collector "0.1.0-SNAPSHOT"
+(defproject stl-collector "0.1.0"
   :description "Library for collecting multiple STL files into a single STL file"
   :url "http://tailoredshapes.com/"
   :license {:name "BSD"


fix: environ plugin emptied .lein-env on startup

--- project.clj
+++ project.clj
@@ -25,10 +25,10 @@
   :url "http://github.so.kadaster.nl/PDOK/featured"
   :license {:name "Eclipse Public License"
             :url "http://www.eclipse.org/legal/epl-v10.html"}
-    :repositories [["releases" "http://mvnrepository.so.kadaster.nl:8081/nexus/content/repositories/releases/"]
+    :repositories [["releases" "http://mvnrepository.so.kadaster.nl:8081/nexus/content/repositories/releases/"]
                    ["osgeo" {:url "http://download.osgeo.org/webdav/geotools/"
                              :snapshots false}]
-                   ["local" "file:repo"]]
+                   ["local" "file:repo"]]
     :mirrors {"*" {:name "kadaster"
                    :url "http://mvnrepository.so.kadaster.nl:8081/nexus/content/repositories/public/"}}
   :dependencies [[cheshire "5.4.0"]
@@ -39,7 +39,7 @@
                   :exclusions [[log4j]]]
                  [compojure "1.3.4"]
                  [stencil "0.4.0"]
-                 [environ "1.0.0"]
+                 [environ "1.0.1"]
                  [http-kit "2.1.18"]
                  [org.clojure/clojure "1.7.0"]
                  [org.clojure/core.async "0.1.346.0-17112a-alpha"]
@@ -61,8 +61,7 @@
                  [ring/ring-json "0.3.1"]
                  [xalan/xalan "2.7.2"]
                  [nl.pdok/gml311-jts "0.0.2"]]
-  :plugins [[lein-environ "1.0.0"]
-            [lein-ring "0.9.6" ]
+  :plugins [[lein-ring "0.9.6" ]
             [lein-filegen "0.1.0-SNAPSHOT"]]
   :ring {:handler pdok.featured.api/app
          :uberwar-name ~uberwar-name}


updated deps

updated deps

--- project.clj
+++ project.clj
@@ -3,7 +3,7 @@
   :url "https://www.domaindrivenarchitecture.org"
   :license {:name "Apache License, Version 2.0"
              :url "https://www.apache.org/licenses/LICENSE-2.0.html"}
-  :dependencies [[dda/dda-pallet "2.1.1"]]
+  :dependencies [[dda/dda-pallet "2.1.2"]]
   :source-paths ["main/src"]
   :resource-paths ["main/resources"]
   :repositories [["snapshots" :clojars]
@@ -34,7 +34,7 @@
                        :resource-paths ["uberjar/resources"]
                        :aot :all
                        :main dda.pallet.dda-user-crate.main
-                       :dependencies [[org.clojure/tools.cli "0.3.5"]
+                       :dependencies [[org.clojure/tools.cli "0.3.7"]
                                       [ch.qos.logback/logback-classic "1.3.0-alpha4"]
                                       [org.slf4j/jcl-over-slf4j "1.8.0-beta1"]]}}
   :local-repo-classpath true)


cljsjs jquery version locked on a specific version

--- project.clj
+++ project.clj
@@ -4,4 +4,4 @@
   :license {:name "GPLv3"
             :url "http://www.eclipse.org/legal/epl-v10.html"}
   :dependencies [[org.clojure/clojure "1.8.0"]
-                 [cljsjs/jquery]])
+                 [cljsjs/jquery "2.2.4-0"]])


lein-release plugin: bumped version from 0.86 to 0.87-SNAPSHOT for next development cycle

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


Version 1.5.3-SNAPSHOT

Version 1.5.3-SNAPSHOT

--- project.clj
+++ project.clj
@@ -1,6 +1,6 @@
 (def http-async-client-version "1.3.0")

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


Do not sign releases to Clojars

Do not sign releases to Clojars

It appears that Clojars has (temporarily?) stopped verifying jar
signatures. The key administration screens have been removed from the
UI, and from [0]:

```
In the wiki documentation it now says, simply that it will check
“if any signature is uploaded, then every artifact has a signature”
but what that is NOT saying is “we confirm the signature belongs to
the clojars account that is attempting to do the publishing”
```

```
...there were minimal security benefits from signing the JARs, as people
didn’t have a web of trust to validate that the GPG signature actually
chained to people they trusted
```

It seems that jar verification v2 is in the discussion phase: [1][2]
In the meantime this disables release signing following example by
re-frame [3]

0: https://clojureverse.org/t/please-how-do-you-configure-gpg-and-clojars/606/2

1: https://github.com/clojars/clojars-web/issues/562

2: https://github.com/clojars/clojars-web/issues/560

3: https://github.com/Day8/re-frame/blob/master/project.clj#L31

--- project.clj
+++ project.clj
@@ -21,4 +21,6 @@
                  [clj-time "0.12.2"]
                  [mysql/mysql-connector-java "5.1.41"]]
   :plugins [[codox "0.8.13"]]
-  :codox {:output-dir "doc/api"})
+  :codox {:output-dir "doc/api"}
+  :deploy-repositories [["releases"  {:sign-releases false :url "https://clojars.org/repo"}]
+                        ["snapshots" {:sign-releases false :url "https://clojars.org/repo"}]])


this makes the lein run tasks work

this makes the lein run tasks work

--- project.clj
+++ project.clj
@@ -7,4 +7,5 @@
                  [cheshire "5.5.0"]
                  [stencil "0.5.0"]
                  [me.raynes/conch "0.8.0"]]
+  :jvm-opts ["-Xmx2048m"]
   :main terraboot.infra/-main)


next iteration

next iteration

--- project.clj
+++ project.clj
@@ -1,4 +1,4 @@
-(defproject com.ladderlife/cellophane "0.3.2"
+(defproject com.ladderlife/cellophane "0.3.3-SNAPSHOT"
   :description "Server-side rendering for Om Next components"
   :url "http://github.com/ladderlife/cellophane"
   :license {:name "Eclipse Public License"


Version 1.5.9-SNAPSHOT

Version 1.5.9-SNAPSHOT

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

-(defproject puppetlabs/trapperkeeper-webserver-jetty9 "1.5.8"
+(defproject puppetlabs/trapperkeeper-webserver-jetty9 "1.5.9-SNAPSHOT"
   :description "A jetty9-based webserver implementation for use with the puppetlabs/trapperkeeper service framework."
   :url "https://github.com/puppetlabs/trapperkeeper-webserver-jetty9"
   :license {:name "Apache License, Version 2.0"


Upgrade to codox 0.9.0.

Upgrade to codox 0.9.0.

--- project.clj
+++ project.clj
@@ -64,10 +64,8 @@
                    :env {:dev true}}
              :uberjar {:env {:production true}
                        :aot :all}}
-  :plugins [[codox "0.8.13"]
+  :plugins [[lein-codox "0.9.0"]
             [lein-environ "1.0.1"]]

-  :codox {:src-dir-uri "http://github.com/brunchboy/afterglow/blob/master/"
-          :src-linenum-anchor-prefix "L"
-          :output-dir "target/doc"}
+  :codox {:source-uri "http://github.com/brunchboy/afterglow/blob/master/{filepath}#L{line}"}
   :min-lein-version "2.0.0")


Prep for 0.1.15

Prep for 0.1.15

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


Prepare for next release cycle.

Prepare for next release cycle.

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


version

version

--- project.clj
+++ project.clj
@@ -1,4 +1,4 @@
-(defproject antler/antlers "0.5.4"
+(defproject caribou/antlers "0.6.0"
   :description "Swift, robust templating in Clojure"
   :dependencies [[org.clojure/clojure "1.5.1"]
                  [scout "0.1.0"]


0.8.1-wip2

--- project.clj
+++ project.clj
@@ -1,4 +1,4 @@
-(defproject storm "0.8.1-wip2-SNAPSHOT"
+(defproject storm "0.8.1-wip2"
   :source-path "src/clj"
   :test-path "test/clj"
   :java-source-path "src/jvm"


lein-release plugin: bumped version from 0.7.2 to 0.7.3-SNAPSHOT for next development cycle

--- project.clj
+++ project.clj
@@ -1,7 +1,7 @@
 (def tk-version "0.5.1")
 (def ks-version "0.7.2")

-(defproject puppetlabs/trapperkeeper-webserver-jetty9 "0.7.2"
+(defproject puppetlabs/trapperkeeper-webserver-jetty9 "0.7.3-SNAPSHOT"
   :description "We are trapperkeeper.  We are one."
   ;; Abort when version ranges or version conflicts are detected in
   ;; dependencies. Also supports :warn to simply emit warnings.


Bumped up version number.

Bumped up version number.

--- project.clj
+++ project.clj
@@ -1,4 +1,4 @@
-(defproject appengine-magic "0.1.0-SNAPSHOT"
+(defproject appengine-magic "0.1.0"
   :description "Google App Engine library for Clojure."
   :repositories {"maven-gae-plugin" "http://maven-gae-plugin.googlecode.com/svn/repository"}
   :dependencies [[org.clojure/clojure "1.2.0"]


Update dependencies

Update dependencies

--- project.clj
+++ project.clj
@@ -13,14 +13,14 @@
                  [clojure.java-time "0.3.2"]
                  [org.threeten/threeten-extra "1.6.0"]
                  [cheshire "5.10.0"]
-                 [selmer "1.12.34"]
+                 [selmer "1.12.40"]
                  [clj-http "3.12.1"]
                  [org.clojure/tools.logging "1.1.0"]
                  [org.slf4j/slf4j-log4j12 "1.7.30"]
                  [com.yubico/yubico-validation-client2 "3.1.0"]
-                 [buddy/buddy-hashers "1.8.0"]
-                 [buddy/buddy-auth "2.2.0"]
-                 [buddy/buddy-sign "3.4.0"]
+                 [buddy/buddy-hashers "1.8.1"]
+                 [buddy/buddy-auth "3.0.1"]
+                 [buddy/buddy-sign "3.4.1"]
                  [org.clojars.pntblnk/clj-ldap "0.0.17"]]
   :main ^:skip-aot env-logger.handler
   :aot [env-logger.handler


Updated project URL

Updated project URL

--- project.clj
+++ project.clj
@@ -1,6 +1,6 @@
 (defproject ez-snake "0.1.0-SNAPSHOT"
   :description "Snake game"
-  :url "http://example.com/FIXME"
+  :url "https://bitbucket.org/ezaretsky/ez-snake"

   :dependencies [[org.clojure/clojure "1.5.1"]
                  [org.clojure/clojurescript "0.0-2080"]


Upgrade to 0.9.12.

Upgrade to 0.9.12.

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


Update dependencies.

Update dependencies.

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

   :dependencies [
     [org.clojure/clojure "1.6.0"] ; Lisp on the JVM http://clojure.org/documentation
-    [org.clojure/clojurescript "0.0-2657"] ; ClojureScript compiler https://github.com/clojure/clojurescript
+    [org.clojure/clojurescript "0.0-2755"] ; ClojureScript compiler https://github.com/clojure/clojurescript
     [ring/ring-jetty-adapter "1.3.2"] ; Web Server https://github.com/ring-clojure/ring
     [ring-basic-authentication "1.0.5"] ; Basic HTTP/S Auth https://github.com/remvee/ring-basic-authentication
     [compojure "1.3.1"] ; Web routing http://github.com/weavejester/compojure
@@ -59,8 +59,8 @@
   }

   :plugins [
-    [lein-ancient "0.5.5"] ; Check for outdated dependencies https://github.com/xsc/lein-ancient
-    [lein-ring "0.8.13"] ; Common ring tasks https://github.com/weavejester/lein-ring
+    [lein-ancient "0.6.1"] ; Check for outdated dependencies https://github.com/xsc/lein-ancient
+    [lein-ring "0.9.1"] ; Common ring tasks https://github.com/weavejester/lein-ring
     [lein-environ "1.0.0"] ; Get environment settings from different sources https://github.com/weavejester/environ
     [lein-cljsbuild "1.0.4"] ; ClojureScript compiler https://github.com/emezeske/lein-cljsbuild
     [lein-cucumber "1.0.2"] ; cucumber-jvm (BDD testing) tasks https://github.com/nilswloka/lein-cucumber


Version 0.2.48

Version 0.2.48

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


Version 6.7.0

Version 6.7.0

--- project.clj
+++ project.clj
@@ -1,4 +1,4 @@
-(def ps-version "6.7.0-SNAPSHOT")
+(def ps-version "6.7.0")

 (defn deploy-info
   [url]


Fix batch sending

Fix batch sending

--- project.clj
+++ project.clj
@@ -42,7 +42,7 @@
   :dependencies [[org.clojure/clojure "1.7.0"]
 		 ;[org.onyxplatform/onyx "0.8.2"]
 		 [org.onyxplatform/onyx "0.8.3-SNAPSHOT"]
-		 [org.onyxplatform/onyx-metrics "0.8.2.8-20151205.102704-11"]
+		 [org.onyxplatform/onyx-metrics "0.8.2.8-20151205.105515-12"]
 		 [riemann-clojure-client "0.4.1"]
                  [gnuplot "0.1.0"]
 		 [cheshire "5.4.0"]])


Updated Codox plugin to 0.6.6

Updated Codox plugin to 0.6.6

--- project.clj
+++ project.clj
@@ -2,9 +2,9 @@
   :description "A fast library for rendering HTML in Clojure"
   :url "http://github.com/weavejester/hiccup"
   :dependencies [[org.clojure/clojure "1.2.1"]]
-  :plugins [[codox "0.6.4"]]
+  :plugins [[codox "0.6.6"]]
   :codox {:exclude [hiccup.compiler]
-          :src-dir-uri "http://github.com/weavejester/hiccup/blob/1.0.4"
+          :src-dir-uri "http://github.com/weavejester/hiccup/blob/1.0.4/"
           :src-linenum-anchor-prefix "L"}
   :profiles
   {:1.3 {:dependencies [[org.clojure/clojure "1.3.0"]]}


Release 0.5.4

Release 0.5.4

--- project.clj
+++ project.clj
@@ -1,4 +1,4 @@
-(defproject org.pinkgorilla/notebook "0.5.4-SNAPSHOT"
+(defproject org.pinkgorilla/notebook "0.5.4"
   :description "A clojure notebook web-app"
   :url "https://github.com/pink-gorilla/notebook"
   :license {:name "MIT"}


Update metadata

Update metadata

--- project.clj
+++ project.clj
@@ -1,6 +1,6 @@
-(defproject compound "0.1.0-SNAPSHOT"
-  :description "FIXME: write description"
-  :url "http://example.com/FIXME"
+(defproject danielneal/compound "0.1.0-SNAPSHOT"
+  :description "A micro structure for reagent data"
+  :url "https://github.com/danielneal/compound"
   :license {:name "Eclipse Public License"
             :url "http://www.eclipse.org/legal/epl-v10.html"}
   :dependencies [[org.clojure/clojure "1.9.0-beta1"]


Version 1.5.4-SNAPSHOT

Version 1.5.4-SNAPSHOT

--- project.clj
+++ project.clj
@@ -1,6 +1,6 @@
 (def http-async-client-version "1.3.0")

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


Disable *warn-on-reflextion*

Disable *warn-on-reflextion*

--- project.clj
+++ project.clj
@@ -8,7 +8,8 @@
   :profiles {:dev {:dependencies [[postgresql "9.3-1102.jdbc41"]
                                   [com.h2database/h2 "1.3.176"]
                                   [cheshire "5.3.1"]]
-                   :global-vars {*warn-on-reflection* true}}}
+                   ;; :global-vars {*warn-on-reflection* true}
+                   }}
   :java-source-paths ["src/java"]
   :dependencies [[org.clojure/clojure "1.6.0"]
                  [org.jooq/jooq "3.5.0"]


Release 1.1.0

Release 1.1.0

--- project.clj
+++ project.clj
@@ -1,4 +1,4 @@
-(defproject superstring "1.1.0-SNAPSHOT"
+(defproject superstring "1.1.0"
   :description "String manipulation library for clojure"
   :url "http://github.com/expez/superstring"
   :license {:name "Eclipse Public License 1.0"


Version 0.4.32

Version 0.4.32

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


Update to release candidate of Clojure.

Update to release candidate of Clojure.

--- project.clj
+++ project.clj
@@ -3,7 +3,7 @@
   :url "https://github.com/brunchboy/afterglow"
   :license {:name "Eclipse Public License"
             :url "http://www.eclipse.org/legal/epl-v10.html"}
-  :dependencies [[org.clojure/clojure "1.7.0-beta3"]
+  :dependencies [[org.clojure/clojure "1.7.0-RC1"]
                  [org.clojure/core.cache "0.6.4"]
                  [org.clojure/tools.nrepl "0.2.10"]
                  [org.clojure/core.async "0.1.346.0-17112a-alpha"]


(PDB-3458) Change the puppetserver-version to SNAPSHOT

The current version, 5.0.0-master-20170329_182047-ga16e296, prevents
use of lein installed versions, and it sounds like we don't need a
specific jar, just some 5.0.0 snapshot.

--- project.clj
+++ project.clj
@@ -1,5 +1,5 @@
 (def pdb-version "5.0.0-SNAPSHOT")
-(def puppetserver-version "5.0.0-master-20170329_182047-ga16e296")
+(def puppetserver-version "5.0.0-master-SNAPSHOT")
 (def clj-parent-version "0.6.1")

 (defn deploy-info


Add clj-audio dependency

Add clj-audio dependency

--- project.clj
+++ project.clj
@@ -26,6 +26,7 @@
                  ;[org.clojure/clojurescript "0.0-3030"]
                  [org.clojure/clojurescript "1.7.10"]
                  [clj-http "2.0.0"]
+                 [clj-audio "0.1.0"]
                  [seesaw "1.4.5"]
                  [cljs-webgl "0.1.5-SNAPSHOT"]
                  [ns-tracker "0.3.0"]


deploy 0.5.3

deploy 0.5.3

--- project.clj
+++ project.clj
@@ -1,4 +1,4 @@
- (defproject com.ladderlife/om-css "0.5.3-SNAPSHOT"
+ (defproject com.ladderlife/om-css "0.5.3"
   :description "Om Next + CSS"
   :url "http://github.com/ladderlife/om-css"
   :license {:name "Eclipse Public License"


bump Clojure 1.9 version to 1.9.0-alpha17 in test

--- project.clj
+++ project.clj
@@ -15,5 +15,5 @@
                    :pedantic? :abort}
              :c17 {:dependencies [[org.clojure/clojure "1.7.0"]]}
              :c18 {:dependencies [[org.clojure/clojure "1.8.0"]]}
-             :c19 {:dependencies [[org.clojure/clojure "1.9.0-alpha15"]]}
+             :c19 {:dependencies [[org.clojure/clojure "1.9.0-alpha17"]]}
              :dln {:jvm-opts ["-Dclojure.compiler.direct-linking=true"]}})


Update nippy and timbre deps

Update nippy and timbre deps

--- project.clj
+++ project.clj
@@ -27,8 +27,8 @@
                  [tinter "0.1.1-SNAPSHOT"]
                  [clj-tiny-astar "0.1.1-SNAPSHOT"]
                  [dorothy "0.0.6"]
-                 [com.taoensso/timbre "3.3.1"]
-                 [com.taoensso/nippy "2.7.1"]
+                 [com.taoensso/timbre "3.4.0"]
+                 [com.taoensso/nippy "2.8.0"]
                  [rm-hull/monet "0.2.1"]]
   :main robinson.core
   :repl-init robinson.core


Increment play-clj version

Increment play-clj version

--- project.clj
+++ project.clj
@@ -24,7 +24,7 @@
                  [org.flatland/ordered "1.5.2"]
                  [org.lpetit/paredit.clj "0.19.3"
                   :exclusions [org.clojure/clojure]]
-                 [play-clj/lein-template "0.3.6"]
+                 [play-clj/lein-template "0.3.7.2"]
                  [seesaw "1.4.4"]]
   :uberjar-exclusions [#"PHPTokenMaker\.class"
                        #"org\/apache\/lucene"]


CMR-5145: Bumped version number for next dev cycle.

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

-(defproject gov.nasa.earthdata/cmr-opendap "1.4.0-SNAPSHOT"
+(defproject gov.nasa.earthdata/cmr-opendap "1.5.0-SNAPSHOT"
   :description "OPeNDAP Integration in the CMR"
   :url "https://github.com/cmr-exchange/cmr-opendap"
   :license {


Update dependencies.

Update dependencies.

--- project.clj
+++ project.clj
@@ -15,12 +15,12 @@
     [cheshire "5.3.1"] ; JSON de/encoding https://github.com/dakrone/cheshire
     [org.flatland/ordered "1.5.2"] ; Ordered hash map https://github.com/flatland/ordered
     [ring/ring-jetty-adapter "1.3.1"] ; Web Server https://github.com/ring-clojure/ring
-    [compojure "1.1.8"] ; Web routing https://github.com/weavejester/compojure
+    [compojure "1.1.9"] ; Web routing https://github.com/weavejester/compojure
     [liberator "0.12.1"] ; WebMachine (REST API server) port to Clojure https://github.com/clojure-liberator/liberator
-    [com.ashafa/clutch "0.4.0-RC1"] ; CouchDB client https://github.com/clojure-clutch/clutch
+    [com.ashafa/clutch "0.4.0"] ; CouchDB client https://github.com/clojure-clutch/clutch
     [clojurewerkz/elastisch "2.1.0-beta6"] ; Client for ElasticSearch https://github.com/clojurewerkz/elastisch
     [environ "1.0.0"] ; Get environment settings from different sources https://github.com/weavejester/environ
-    [com.taoensso/timbre "3.3.0"] ; Logging https://github.com/ptaoussanis/timbre
+    [com.taoensso/timbre "3.3.1"] ; Logging https://github.com/ptaoussanis/timbre
   ]

   :profiles {


Add :license and :url to project.clj

Add :license and :url to project.clj

--- project.clj
+++ project.clj
@@ -1,6 +1,10 @@
 (defproject mixradio/party "1.0.3-SNAPSHOT"

   :description "A Clojure library that wraps the Curator service discovery/registration API."
+
+  :license "https://github.com/mixradio/party/blob/master/LICENSE"
+
+  :url "https://github.com/mixradio/party"

   :dependencies [[cheshire "5.5.0"]
                  [com.cemerick/url "0.1.1"]


dep datomic-free only

dep datomic-free only

--- project.clj
+++ project.clj
@@ -4,6 +4,7 @@
   :license {:name "Eclipse Public License"
             :url "http://www.eclipse.org/legal/epl-v10.html"}
   :dependencies [[compojure "1.1.6"]
+                 [com.datomic/datomic-free "0.9.4556"]
                  [datomic-schematode "0.1.0-RC1"]
                  [enlive "1.1.5"]
                  [http-kit "2.1.16"]
@@ -14,8 +15,6 @@
   :source-paths ["src/clj" "src/cljs"]
   :resource-paths ["resources"]
   :plugins [[lein-cloverage "1.0.2"]]
-  :profiles {:prod-pro {:dependencies [[com.datomic/datomic-pro "0.9.4556"]]}
-             :prod     {:dependencies [[com.datomic/datomic-free "0.9.4699"]]}
-             :dev      {:dependencies [[org.clojure/tools.namespace "0.2.4"]
-                                       [com.datomic/datomic-free "0.9.4699"]]
-                        :source-paths ["dev"]}})
+  :profiles {:dev {:dependencies [[org.clojure/tools.namespace "0.2.4"]
+                                  [com.datomic/datomic-free "0.9.4699"]]
+                   :source-paths ["dev"]}})


Dependent library: clj-flotr

Dependent library: clj-flotr

--- project.clj
+++ project.clj
@@ -12,6 +12,7 @@
                    [ring/ring-core "1.3.2"]
                    [ring/ring-jetty-adapter "1.3.2"]
                    [clojure-ini "0.0.1"]
+                   [org.clojars.tisnik/clj-flotr "0.2.0-SNAPSHOT"]
                    [hiccup "1.0.4"]]
     :dev-dependencies [[lein-ring "0.8.10"]]
     :plugins [[lein-ring "0.8.10"]]


Bumping version again

Bumping version again

--- project.clj
+++ project.clj
@@ -24,7 +24,7 @@
                  [cascalog-lzo "0.1.0-wip"]
                  [cascalog-checkpoint "0.1.1"]
                  [backtype/dfs-datastores "1.1.3-SNAPSHOT"]
-                 [backtype/dfs-datastores-cascading "1.1.3"]
+		 [backtype/dfs-datastores-cascading "1.1.4"]
                  [org.apache.thrift/libthrift "0.8.0" :exclusions [org.slf4j/slf4j-api]]]
   :dev-dependencies [[org.apache.hadoop/hadoop-core "0.20.2-dev"]
                      [midje-cascalog "0.4.0"]]


Version 2.0.1

Version 2.0.1

--- project.clj
+++ project.clj
@@ -1,4 +1,4 @@
-(defproject dda/dda-user-crate "2.0.1-SNAPSHOT"
+(defproject dda/dda-user-crate "2.0.1"
   :description "A crate to handle users"
   :url "https://www.domaindrivenarchitecture.org"
   :license {:name "Apache License, Version 2.0"


Replace conman by hikari-cp and hugsql

Replace conman by hikari-cp and hugsql

--- project.clj
+++ project.clj
@@ -17,7 +17,8 @@
                   :exclusions [ch.qos.logback/logback-classic]]
                  [selmer "1.10.6"]
                  [mount "0.1.11"]
-                 [conman "0.6.3"]
+                 [hikari-cp "1.7.5"]
+                 [com.layerware/hugsql "0.4.7"]
                  [org.postgresql/postgresql "9.4.1212"]]
   :main madouc.core
   :profiles {:dev {:resource-paths ["config/dev"]}


(maint) Bump clj-parent to 4.5.4

(maint) Bump clj-parent to 4.5.4

This includes an update to trapperkeeper-metrics that adds trapperkeeper
authentication to its endpoints.

--- project.clj
+++ project.clj
@@ -1,5 +1,5 @@
 (def pdb-version "6.11.2-SNAPSHOT")
-(def clj-parent-version "4.5.3")
+(def clj-parent-version "4.5.4")

 (defn true-in-env? [x]
   (#{"true" "yes" "1"} (System/getenv x)))


Minor fixes on project.clj file.

Minor fixes on project.clj file.

--- project.clj
+++ project.clj
@@ -18,8 +18,10 @@
                       octet.spec.string
                       octet.spec.collections]
             :target "doc/dist/latest/api"
-            :src-uri "http://github.com/funcool/beicon/blob/master/"
+            :src-uri "http://github.com/funcool/codeina/blob/master/"
             :src-uri-prefix "#L"}

-  :plugins [[funcool/codeina "0.5.0"]])
+  :plugins [[funcool/codeina "0.5.0"]
+            [lein-ancient "0.6.10"]])

+


Update to clj-tuple 0.1.1

Update to clj-tuple 0.1.1

--- project.clj
+++ project.clj
@@ -4,7 +4,7 @@
   :license {:name "Eclipse Public License"
             :url "http://www.eclipse.org/legal/epl-v10.html"}
   :dependencies [[org.clojure/clojure "1.5.0"]
-                 [clj-tuple "0.1.0" :exclusions [reiddraper/simple-check]]
+                 [clj-tuple "0.1.1" :exclusions [reiddraper/simple-check]]
                  [codox-md "0.2.0"]]
   :global-vars {*warn-on-reflection* true}
   :codox {:writer codox-md.writer/write-docs}


release 2.0.2

release 2.0.2

--- project.clj
+++ project.clj
@@ -6,7 +6,7 @@
 ;; babel.http: workbook, compojure http routes, querying from GETs, updating from POSTs, PUTs and PATCHes. all the ring/* and servlet-api :dependencies go here.
 ;; babel.<2 letter language code> babel.es, babel.en, etc.
 ;;
-(defproject babel "2.0.2-SNAPSHOT"
+(defproject babel "2.0.2"
   :description "A library for generation and parsing 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."}


start working on 2.7.8

start working on 2.7.8

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


[CS] Disable auto cleaning of target for cljx

--- project.clj
+++ project.clj
@@ -21,6 +21,7 @@
                  [com.cemerick/friend "0.2.1" :exclusions [org.clojure/core.cache]]
                  [com.novemberain/monger "2.0.0"]]
   :source-paths ["src/clj" "src/cljx"]
+  :auto-clean false
   :cljx {:builds [{:source-paths ["src/cljx"]
                    :output-path "target/classes"
                    :rules :clj}


Version 159-SNAPSHOT

Version 159-SNAPSHOT

--- project.clj
+++ project.clj
@@ -1,4 +1,4 @@
-(defproject clojars-web "158"
+(defproject clojars-web "159-SNAPSHOT"
   :min-lein-version "2.0.0"
   :dependencies [[org.clojure/clojure "1.10.3"]
                  [org.clojure/core.memoize "1.0.253"]


Ready for next work

Ready for next work

--- project.clj
+++ project.clj
@@ -1,4 +1,4 @@
-(defproject reply "0.1.0-alpha2"
+(defproject reply "0.1.0-SNAPSHOT"
   :description "REPL-y: A fitter, happier, more productive REPL for Clojure."
   :dependencies [[org.clojure/clojure "1.3.0"]
                  [org.clojars.trptcolin/jline "2.6-alpha1"]


Update for heroku

Update for heroku

--- project.clj
+++ project.clj
@@ -10,9 +10,14 @@
                  [clj-time "0.8.0"]
                  [org.clojure/data.json "0.2.5"]
                  [javax.servlet/servlet-api "2.5"]
+                 [ring/ring-jetty-adapter "1.2.2"]
+                 [environ "0.5.0"]
                  [compojure "1.2.0"]]

   :plugins [[lein-ring "0.8.12"]]
   :main obb-rules-api.routes/app
   :ring {:handler obb-rules-api.routes/app}
-  :profiles {:dev {:dependencies [[ring-mock "0.1.5"]]}})
+  :hooks [environ.leiningen.hooks]
+  :uberjar-name "obb-api-rules-standalone.jar"
+  :profiles {:dev {:dependencies [[ring-mock "0.1.5"]]}
+             :production {:env {:production true}}})


update to lein-protobuf with auto-hooks

update to lein-protobuf with auto-hooks

--- project.clj
+++ project.clj
@@ -7,7 +7,7 @@
                  [ordered-collections "0.4.0"]
                  [useful "0.8.2-alpha1"]
                  [schematic "0.0.5"]]
-  :plugins [[lein-protobuf "0.2.0-beta3"]]
+  :plugins [[lein-protobuf "0.2.0-beta5"]]
   :aliases {"testall" ["with-profile" "dev,default:dev,1.3,default:dev,1.5,default" "test"]}
   :profiles {:1.3 {:dependencies [[org.clojure/clojure "1.3.0"]]}
              :1.5 {:dependencies [[org.clojure/clojure "1.5.0-master-SNAPSHOT"]]}
@@ -17,6 +17,5 @@
                                        :snapshots true
                                        :releases {:checksum :fail :update :always}}}
   :protobuf-version "2.4.1"
-  :hooks [leiningen.protobuf]
   :checksum-deps true
   :java-source-paths ["src"])


Add dependendy to http-kit to enable http requests

--- project.clj
+++ project.clj
@@ -7,6 +7,7 @@
                  [org.clojure/core.async "0.1.267.0-0d7780-alpha"]
                  [clojure-csv/clojure-csv "2.0.1"]
                  [clj-time "0.6.0"]
+                 [http-kit "2.1.16"]
                  [io.gatling/gatling-charts "2.0.0-M3a"]
                  [io.gatling.highcharts/gatling-charts-highcharts "2.0.0-M3a"]]
   :repositories { "excilys" "http://repository.excilys.com/content/groups/public" }


Prepare for next release cycle.

Prepare for next release cycle.

--- project.clj
+++ project.clj
@@ -1,4 +1,4 @@
-(defproject onyx-cheat-sheet "0.9.10.0-beta6"
+(defproject onyx-cheat-sheet "0.9.10.0-SNAPSHOT"
   :description "Cheat sheet for Onyx"
   :url "https://github.com/onyx-platform/onyx-cheat-sheet"
   :license {:name "Eclipse Public License"


Update codox config to generate source links properly.

--- project.clj
+++ project.clj
@@ -123,11 +123,10 @@
   ;; ----- Clojure API Documentation -----

   :codox {
-    :sources ["src/fcms/resources"]
-    :exclude [fcms.resources.collection-resource]
+    :include [fcms.resources.common fcms.resources.collection fcms.resources.item fcms.resources.taxonomy]
     :output-dir "../Falkland-CMS-docs/API/Clojure"
-    ;:src-dir-uri "http://github.com/SnootyMonkey/Falkland-CMS/blob/master/"
-    ;:src-linenum-anchor-prefix "L" ; for Github
+    :src-dir-uri "http://github.com/SnootyMonkey/Falkland-CMS/blob/master/"
+    :src-linenum-anchor-prefix "L" ; for Github
   }

   ;; ----- ClojureScript -----


Changed build file to build against standard mesos 0.14.2 and storm 0.9.0-rc3.

--- project.clj
+++ project.clj
@@ -1,4 +1,4 @@
-(defproject storm/storm-mesos "airbnb"
+(defproject storm/storm-mesos "0.9-rc3"
   :description "Storm integration with the Mesos cluster manager"
   :source-paths ["src/clj"]
   :java-source-paths ["src/jvm"]
@@ -6,9 +6,9 @@
   :jvm-opts ["-Djava.library.path=/usr/local/lib:/opt/local/lib:/usr/lib"]
   :repositories {"mesosphere-public-repo" "http://s3.amazonaws.com/mesosphere-maven-public"}
   :dependencies [
-    [org.apache.mesos/mesos "0.14.0"]
+    [org.apache.mesos/mesos "0.14.2"]
     [com.google.protobuf/protobuf-java "2.4.1"]
-    [storm-core "0.9.0-rc3"]
+    [storm "0.9.0-rc3"]
     [org.apache.commons/commons-exec "1.1"]
     [commons-lang "2.6"]
     [com.googlecode.json-simple/json-simple "1.1"]


Switch back to snapshot version.

Switch back to snapshot version.

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


release 0.3.0

release 0.3.0

--- project.clj
+++ project.clj
@@ -1,4 +1,4 @@
-(defproject clj-kafka/clj-kafka "0.3.0-0.8.1.1-SNAPSHOT"
+(defproject clj-kafka/clj-kafka "0.3.0-0.8.1.1"
   :min-lein-version "2.0.0"
   :url "https://github.com/pingles/clj-kafka"
   :license {:name "Eclipse Public License"


upgrade deps & bump version to 0.3.0

upgrade deps & bump version to 0.3.0

--- project.clj
+++ project.clj
@@ -1,4 +1,4 @@
-(defproject zsau/id3 "0.1.2"
+(defproject zsau/id3 "0.2.0"
 	:description "Simple ID3v2 parser"
 	:url "https://github.com/zsau/id3"
 	:license {
@@ -7,5 +7,5 @@
 	:profiles {
 		:dev {:resource-paths ["test/resources"]}}
 	:dependencies [
-		[org.clojure/clojure "1.8.0"]
-		[smee/binary "0.5.1"]])
+		[org.clojure/clojure "1.9.0"]
+		[smee/binary "0.5.3"]])