Namespace declaration fixed

Namespace declaration fixed

--- jvm-runner/src/clojure/codewars/runner/java.clj
+++ jvm-runner/src/clojure/codewars/runner/java.clj
@@ -1,5 +1,5 @@
-(ns codewars.runner
-  (:require [codewars.runner :refer [run]]
+(ns codewars.runner.java
+  (:require [codewars.runner :refer [solution-only full-project]]
             [codewars.clojure.test]
             [clojure.java.io :as io]
             [codewars.util :refer [write-code!]])


Update json response

Update json response

remote: Support for password authentication was removed on August 13, 2021.
remote: Please see https://docs.github.com/en/get-started/getting-started-with-git/about-remote-repositories#cloning-with-https-urls for information on currently recommended modes of authentication.
fatal: Authentication failed for 'https://github.com/aarkerio/cmsclj.git/'


Cleanup

Cleanup

remote: Support for password authentication was removed on August 13, 2021.
remote: Please see https://docs.github.com/en/get-started/getting-started-with-git/about-remote-repositories#cloning-with-https-urls for information on currently recommended modes of authentication.
fatal: Authentication failed for 'https://github.com/democracyworks/election-notification-works.git/'


documentation improvements

documentation improvements

remote: Support for password authentication was removed on August 13, 2021.
remote: Please see https://docs.github.com/en/get-started/getting-started-with-git/about-remote-repositories#cloning-with-https-urls for information on currently recommended modes of authentication.
fatal: Authentication failed for 'https://github.com/democracyworks/partner-works.git/'


Iruzkinak paneletan

Iruzkinak paneletan

remote: Support for password authentication was removed on August 13, 2021.
remote: Please see https://docs.github.com/en/get-started/getting-started-with-git/about-remote-repositories#cloning-with-https-urls for information on currently recommended modes of authentication.
fatal: Authentication failed for 'https://github.com/lnmnd/magnet.bez.git/'


Seven Languages in Seven Weeks: Clojure day 2.

error: pathspec 'SevenLanguages/Clojure/day2.clj' did not match any file(s) known to git

--- SevenLanguages/Clojure/day2.clj
+++ SevenLanguages/Clojure/day2.clj
@@ -0,0 +1,9 @@
+(defmacro unless [test body else]
+    (list 'if (list 'not test) body else))
+
+(defprotocol MyProtocol
+    (shiz [_ c]))
+
+(defrecord MyRecord [some-key] MyProtocol
+    (shiz [_ c] {some-key c}))
+


update project.clj

update project.clj

--- labs/architecture-examples/om/project.clj
+++ labs/architecture-examples/om/project.clj
@@ -1,4 +1,4 @@
-(defproject react-cljs "0.1.0-SNAPSHOT"
+(defproject todomvc-om "0.1.0-SNAPSHOT"
   :description "FIXME: write this!"
   :url "http://example.com/FIXME"

@@ -18,17 +18,18 @@
                 :output-dir "out"
                 :optimizations :none
                 :source-map true
-                :foreign-libs [{:file "reactjs/react.js"
+                :foreign-libs [{:file "om/react.js"
                                 :provides ["React"]}]
-                :externs ["reactjs/externs/react.js"]}}
+                :externs ["om/externs/react.js"]}}
              {:id "release"
               :source-paths ["src"]
               :compiler {
                 :output-to "app.js"
                 :optimizations :advanced
                 :pretty-print false
-                :foreign-libs [{:file "reactjs/react.js"
+                :output-wrapper false
+                :foreign-libs [{:file "om/react.js"
                                 :provides ["React"]}]
-                :externs ["reactjs/externs/react.js"]
+                :externs ["om/externs/react.js"]
                 :closure-warnings
                 {:non-standard-jsdoc :off}}}]})


New module utils

New module utils

error: pathspec 'src/clouseau/utils.clj' did not match any file(s) known to git

--- src/clouseau/utils.clj
+++ src/clouseau/utils.clj
@@ -0,0 +1,72 @@
+;;;
+;;;   Clouseau
+;;;
+;;;    Copyright (C) 2015, 2016  Pavel Tisnovsky <ptisnovs@redhat.com>
+;;;
+;;; Clouseau is free software; you can redistribute it and/or modify
+;;; it under the terms of the GNU General Public License as published by
+;;; the Free Software Foundation; either version 2, or (at your option)
+;;; any later version.
+;;;
+;;; Clouseau is distributed in the hope that it will be useful, but
+;;; WITHOUT ANY WARRANTY; without even the implied warranty of
+;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+;;; General Public License for more details.
+;;;
+;;; You should have received a copy of the GNU General Public License
+;;; along with Clouseau; see the file COPYING.  If not, write to the
+;;; Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+;;; 02110-1301 USA.
+;;;
+;;; Linking this library statically or dynamically with other modules is
+;;; making a combined work based on this library.  Thus, the terms and
+;;; conditions of the GNU General Public License cover the whole
+;;; combination.
+;;;
+;;; As a special exception, the copyright holders of this library give you
+;;; permission to link this library with independent modules to produce an
+;;; executable, regardless of the license terms of these independent
+;;; modules, and to copy and distribute the resulting executable under
+;;; terms of your choice, provided that you also meet, for each linked
+;;; independent module, the terms and conditions of the license of that
+;;; module.  An independent module is a module which is not derived from
+;;; or based on this library.  If you modify this library, you may extend
+;;; this exception to your version of the library, but you are not
+;;; obligated to do so. If you do not wish to do so, delete this
+;;; exception statement from your version.
+;;;
+
+(ns clouseau.utils)
+
+(defn third
+    "Simple utility function - returns third item from a given sequence."
+    [coll]
+    (nth coll 2))
+
+(defn substring
+    "Call method String.substring()."
+    ([^String s from to]
+     (.substring s from to))
+    ([^String s from]
+     (.substring s from)))
+
+(defn startsWith
+    "Call method String.startsWith()."
+    [^String s pattern]
+    (.startsWith s pattern))
+
+(defn endsWith
+    "Call method String.endsWith()."
+    [^String s pattern]
+    (.endsWith s pattern))
+
+(defn contains
+    "Call method String.contains()."
+    [^String s pattern]
+    (.contains s pattern))
+
+(defn replaceAll
+    "Call method String.replaceAll()."
+    [^String s pattern replacement]
+    (.replaceAll s pattern replacement))
+


packaged

packaged

remote: Support for password authentication was removed on August 13, 2021.
remote: Please see https://docs.github.com/en/get-started/getting-started-with-git/about-remote-repositories#cloning-with-https-urls for information on currently recommended modes of authentication.
fatal: Authentication failed for 'https://github.com/clojure-ml/cml.git/'


Added whitespace between list items

Added whitespace between list items

remote: Support for password authentication was removed on August 13, 2021.
remote: Please see https://docs.github.com/en/get-started/getting-started-with-git/about-remote-repositories#cloning-with-https-urls for information on currently recommended modes of authentication.
fatal: Authentication failed for 'https://github.com/hudren/ebook-novel.git/'


Refactor: rename components for clarity...

... and format the three main column sections so that they appear in the
code as they do visually in the browser.

remote: Support for password authentication was removed on August 13, 2021.
remote: Please see https://docs.github.com/en/get-started/getting-started-with-git/about-remote-repositories#cloning-with-https-urls for information on currently recommended modes of authentication.
fatal: Authentication failed for 'https://github.com/Reefersleep/sleepydo.git/'


Clojure namespace eample

Clojure namespace eample

error: pathspec 'clojure/energy.clj' did not match any file(s) known to git

--- clojure/energy.clj
+++ clojure/energy.clj
@@ -0,0 +1,14 @@
+(ns physics)
+(defn energy [m]
+  (let [c 299792458] (* m c c)))
+
+(ns food)
+(defn energy [grams component]
+  (let [density {:fat 37, :carb 17, :protein 17, :fiber 8}]
+    (* grams (density component))))
+
+(ns user)
+(println (food/energy 100 :protein))
+(println (physics/energy 100))
+(use 'food)
+(println (energy 5 :fat))


[WM WR] add test for finding notification-type entity

remote: Support for password authentication was removed on August 13, 2021.
remote: Please see https://docs.github.com/en/get-started/getting-started-with-git/about-remote-repositories#cloning-with-https-urls for information on currently recommended modes of authentication.
fatal: Authentication failed for 'https://github.com/democracyworks/notification-works.git/'


Adding lein/profiles.clj with test-refresh

error: pathspec 'lein/profiles.clj' did not match any file(s) known to git

--- lein/profiles.clj
+++ lein/profiles.clj
@@ -0,0 +1 @@
+{:user {:plugins [[com.jakemccrary/lein-test-refresh "0.9.0"]]}}


non tail-recursive version.

non tail-recursive version.

error: pathspec 'clojure/grains/grains.clj' did not match any file(s) known to git

--- clojure/grains/grains.clj
+++ clojure/grains/grains.clj
@@ -0,0 +1,6 @@
+(ns grains)
+
+(defn square [n]
+  (if (= n 1)
+      1
+      (* 2 (square (dec n)))))


set the :model to "install" when doing :install activity.  set the :model_id to the `user_id` on :user-joined activity entries.  and make the proces-activity-event public so that we can use it for testing easily.

--- src/metabase/events/activity_feed.clj
+++ src/metabase/events/activity_feed.clj
@@ -119,11 +119,12 @@
   (when (and (= :user-login topic)
              (= (:session_id object) (db/sel :one :field [Session :id] :user_id (:user_id object))))
     (db/ins Activity
-         :topic :user-joined
-         :user_id (:user_id object)
-         :model (topic->model topic))))
+      :topic    :user-joined
+      :user_id  (:user_id object)
+      :model    (topic->model topic)
+      :model_id (:user_id object))))

-(defn- process-activity-event
+(defn process-activity-event
   "Handle processing for a single event notification received on the activity-feed-channel"
   [activity-event]
   ;; try/catch here to prevent individual topic processing exceptions from bubbling up.  better to handle them here.
@@ -134,7 +135,7 @@
         "dashboard" (process-dashboard-activity topic object)
         "database"  (process-database-activity topic object)
         "install"   (when-not (db/sel :one :fields [Activity :id])
-                      (db/ins Activity :topic :install))
+                      (db/ins Activity :topic "install" :model "install"))
         "user"      (process-user-activity topic object)))
     (catch Throwable e
       (log/warn (format "Failed to process activity event. %s" (:topic activity-event)) e))))


test fix ?

test fix ?

--- test/metabase/test/data/interface.clj
+++ test/metabase/test/data/interface.clj
@@ -50,10 +50,11 @@
                                                        (s/upper-case (:table-name this))}]))

   DatabaseDefinition
-  (metabase-instance [this engine-kw]
+  (metabase-instance [{:keys [database-name]} engine-kw]
+    (assert (string? database-name))
     (assert (keyword? engine-kw))
     (setup-db-if-needed :auto-migrate true)
-    (sel :one Database :name (:database-name this) :engine (name engine-kw))))
+    (sel :one Database :name database-name, :engine (name engine-kw))))

 ;; ## IDatasetLoader


removing a lot of un-needed code

removing a lot of un-needed code

remote: Support for password authentication was removed on August 13, 2021.
remote: Please see https://docs.github.com/en/get-started/getting-started-with-git/about-remote-repositories#cloning-with-https-urls for information on currently recommended modes of authentication.
fatal: Authentication failed for 'https://github.com/seanhagen/baddit.git/'


is-diff does not break on non-collection values

remote: Support for password authentication was removed on August 13, 2021.
remote: Please see https://docs.github.com/en/get-started/getting-started-with-git/about-remote-repositories#cloning-with-https-urls for information on currently recommended modes of authentication.
fatal: Authentication failed for 'https://github.com/Zallin/fhirvc.git/'


Let #'cats.context/get-current handle the exception funcool/cats#55

--- src/cats/core.cljc
+++ src/cats/core.cljc
@@ -505,9 +505,7 @@
   value, and a collection of values, perform a left-associative fold."
   ([f z xs]
    (if (empty? xs)
-     (or (some-> (get-current-context) (return z))
-         ;; TODO: write better exception message
-         (throw (Exception. "missing context")))
+     (return (get-current-context) z)
      (let [[h & t] xs]
        (mlet [z' (f z h)]
          (if (empty? t)


:tada: Add namespace for performance measuring and debugging tools.

error: pathspec 'frontend/src/uxbox/util/perf.cljc' did not match any file(s) known to git

--- frontend/src/uxbox/util/perf.cljc
+++ frontend/src/uxbox/util/perf.cljc
@@ -0,0 +1,19 @@
+;; This Source Code Form is subject to the terms of the Mozilla Public
+;; License, v. 2.0. If a copy of the MPL was not distributed with this
+;; file, You can obtain one at http://mozilla.org/MPL/2.0/.
+;;
+;; Copyright (c) 2015-2019 Andrey Antukh <niwi@niwi.nz>
+
+(ns uxbox.util.perf
+  "Performance and debugging tools."
+  #?(:cljs (:require-macros [uxbox.util.perf])))
+
+#?(:clj
+   (defmacro with-measure
+     [name & body]
+     `(let [start# (js/performance.now)
+            res# (do ~@body)
+            end# (js/performance.now)
+            time# (.toFixed (- end# start#) 2)]
+        (println (str "[perf|" ~name "] => " time#))
+        res#)))


Quote hyphanated-words in search queries, so that foo-bar is interpreted as foo-bar instead of foo AND NOT bar.

--- src/clojars/db.clj
+++ src/clojars/db.clj
@@ -1,8 +1,8 @@
 (ns clojars.db
   (:use [clojars :only [config]]
         clojure.contrib.sql
-        clojure.contrib.duck-streams
-        [clojure.contrib.str-utils2 :only [join]])
+        clojure.contrib.duck-streams)
+  (:require [clojure.string :as str])
   (:import java.security.MessageDigest
            java.util.Date
            java.io.File))
@@ -172,8 +172,13 @@
        :created    (Date.)
        :description (:description jarmap)
        :homepage   (:homepage jarmap)
-       :authors    (join ", " (map #(.replace % "," "")
-                                   (:authors jarmap)))}))))
+       :authors    (str/join ", " (map #(.replace % "," "")
+                                       (:authors jarmap)))}))))
+
+(defn quote-hyphanated
+  "Wraps hyphated-words in double quotes."
+  [s]
+  (str/replace s #"\w+(-\w+)+" "\"$0\""))

 (defn search-jars [query & [offset]]
   ;; TODO make search less stupid, figure out some relevance ranking
@@ -183,7 +188,7 @@
             "content match ?"
             "limit 50 "
             "offset ?")
-       query
+       (quote-hyphanated query)
        (or offset 0)]
     ;; TODO: do something less stupidly slow
     (vec (map #(find-jar (:group_name %) (:jar_name %)) rs))))


clojure 7

clojure 7

error: pathspec 'clojure/7.clj' did not match any file(s) known to git

--- clojure/7.clj
+++ clojure/7.clj
@@ -0,0 +1,8 @@
+(def prime-gen
+  (let [primes (atom [])]
+    (for [n (iterate inc 2)
+            :when (not-any? #(zero? (mod n %))
+                            (filter #(<= % (Math/sqrt n)) @primes))]
+         (do (swap! primes conj n) n))))
+
+(println (nth prime-gen 10000))


Added functional programming learning test for Clojure

error: pathspec 'app_generators/clojure/templates/test/learning/about_functional_programming.clj' did not match any file(s) known to git

--- app_generators/clojure/templates/test/learning/about_functional_programming.clj
+++ app_generators/clojure/templates/test/learning/about_functional_programming.clj
@@ -0,0 +1,112 @@
+(ns learning.about-functional-programming
+  (:use clojure.test))
+
+; An example of breaking down existing code as learning tests,
+; as well as setting up a learning test that you can practice.
+
+; From Stu Halloway's Programming Clojure
+
+(defn fibo []
+  (map first (iterate (fn [[a b]] [b (+ a b)]) [0 1])))
+
+(deftest fibo-is-an-infinite-sequence
+  (are [x expected] (= x expected)
+    (take 7 (fibo)) '(0 1 1 2 3 5 8)
+    (nth (fibo) 5) 5
+    (rem (nth (fibo) 10000) 100000) 66875
+    (rem (nth (fibo) 100000) 100000) 46875
+; This one takes a few seconds
+;    (rem (nth (fibo) 1000000) 1000000) 546875
+    ))
+
+; This is succinct, but not exactly intuitive if you're new to Clojure.
+; Let's break it down.
+
+; Basic forms: (+ a b)
+(deftest addition-as-basic-form
+  (is (= 5 (+ 2 3))))
+
+; Vectors: [b (+ a b)]
+(defn next-pair [[a b]]
+    [b (+ a b)])
+
+(deftest seq-functions-work-on-vectors
+  (are [x expected] (= x expected)
+    (next-pair [1 2]) [2 3]
+    (next-pair [3 5]) [5 8]))
+
+; Now we can start seeing the logic of considering each fib
+; as a pair.
+
+; Replace additive-vector with the fn special form: (fn [[a b]] [b (+ a b)])
+(deftest fn-creates-anonymous-functions
+  (let [next-pair-fn (fn [[a b]] [b (+ a b)])]
+  (are [x expected] (= x expected)
+    (next-pair-fn [1 2]) [2 3]
+    (next-pair-fn [3 5]) [5 8])))
+
+; we see from page 118: You can think of iterate as the inﬁnite extension of range
+; Let's experiment:
+(deftest range-is-finite
+  (are [x expected] (= x expected)
+    (range 1 10 2) '(1 3 5 7 9)
+    (range 0 20 5) '(0 5 10 15)))
+
+; iterate and lazy sequences
+; Given that this will introduce an infinite sequence, we'll need to
+; heed the advice about creating a finite view onto the infinite collection.
+; There are a few examples of such methods in our original unit test, and
+; this is a good opportunity to start experimenting with them.
+(deftest iterate-over-infinite-sequences-with-lazy-seqs
+  (let [fib (iterate (fn [[a b]] [b (+ a b)]) [0 1])]
+  (are [desc x expected] (= x expected)
+    "" (first fib) [0 1]
+    "" (take 3 fib) '([0 1] [1 1] [1 2])
+    "nth returns the value at the index" (nth fib 3) [2 3]
+    )))
+
+; So we can now produce pairs of fibonacci numbers.
+; But we only want the first values of each pair.
+; (doc map) at the REPL tells us why we need map:
+; Returns a lazy sequence consisting of the result of applying f to the
+; set of first items of each coll...
+; let's do some simple experiments
+(deftest using-map
+  (are [desc x expected] (= x expected)
+  "double the values in a range" (map (fn [n] (* 2 n)) (range 0 6)) '(0 2 4 6 8 10)
+ ))
+
+; seeing that map takes a function and applies it to each member of a sequence, it's
+; now easy to see what our original fibo function is doing.
+; Let's recap:
+; We define an anonymous function that takes two arguments, a and b, and returns b and the sum of a and b as a vector.
+; Iterate begins with the values 0 and 1 and continues forever, applying the function to each value to calculate the next.
+; This produces pairs of Fibonacci numbers.
+; Since we only want the first values of each pair, we transform the result using map by applying first to each of the pairs
+; in the sequence. This result is itself a lazy sequence, so we must use functions like take and nth to realize the sequence
+; and retrieve the values in which we're interested.
+; Given the terseness of the code and the verbiage of the English translation, we begin to see why people say Clojure is
+; so expressive!
+
+; In the style of Ruby koans, here's a way to start reviewing the implementation so you can practice.
+
+; Let's give ourselves a utility method to make the tests more readable.
+(defn ? []
+    0)
+
+; What would you write to get the following learning tests to pass?
+(deftest review-session
+  (are [desc x expected] (= x expected)
+    "addition as basic form" (?) 5
+    "generate the sequence of odd integers from 1 to 10" (?) '(1 3 5 7 9)
+    "generate the factors of five less than 20" (?) '(0 5 10 15)
+      ))
+
+; Having just seen these, you probably saw right away that we need to replace our (?)'s with
+; (+ 3 2), (range 1 10 2), and (range 0 20 5). How about the definition of the fibo function? Can you write it from
+; memory? Go ahead, try...I'll wait.
+; Did you get it?
+; Now how about if you saw these tomorrow? After a week from now? A month?
+; By answering these (?)'s, you're forced to retrieve the information you've just seen.
+; It turns out that this retrieval step is a powerful learning tool.
+


textarea edukiarentzat

textarea edukiarentzat


Eliminate all reflection.

Eliminate all reflection.

--- src/clojure/abracad/avro.clj
+++ src/clojure/abracad/avro.clj
@@ -5,10 +5,13 @@
             [clojure.walk :refer [postwalk]]
             [cheshire.core :as json]
             [abracad.avro.util :refer [returning mangle unmangle]])
-  (:import [java.io ByteArrayOutputStream InputStream EOFException]
+  (:import [java.io
+             ByteArrayOutputStream EOFException File InputStream OutputStream]
            [clojure.lang Named]
            [org.apache.avro Schema Schema$Parser Schema$Type]
-           [org.apache.avro.file CodecFactory DataFileWriter DataFileReader]
+           [org.apache.avro.file
+             CodecFactory DataFileWriter DataFileReader SeekableInput
+             SeekableFileInput]
            [org.apache.avro.io
              DatumReader DatumWriter Decoder DecoderFactory
              Encoder EncoderFactory]
@@ -39,22 +42,36 @@

 (defn ^:private codec-for
   "Return Avro codec factory for `codec`."
-  {:tag 'org.apache.avro.file.CodecFactory}
+  {:tag `CodecFactory}
   [codec] (if-not (string? codec) codec (CodecFactory/fromString codec)))

-(defn ^:private sink-for
-  "Return sinkable endpoint for `sink`."
-  [sink] (if-not (string? sink) sink (io/file sink)))
+(defn ^:private source-for
+  "Return seekable input for `source`."
+  {:tag `SeekableInput}
+  [source]
+  (condp instance? source
+    SeekableInput source
+    File          (SeekableFileInput. ^File source)
+    String        (SeekableFileInput. (io/file source))))

 (defn ^:private raw-schema?
   "True if schema `source` should be parsed as-is."
   [source] (or (string? source) (instance? InputStream source)))

 (def ^:private primitive-types
-  (->> Schema$Type .getEnumConstants (map #(.getName %)) (into #{})))
+  "Set of Avro primitive type schema strings."
+  (->> Schema$Type .getEnumConstants
+       (map #(.getName ^Schema$Type %))
+       (into #{})))

 (defn ^:private named-schema?
   [^Schema schema] (-> schema .getFullName primitive-types not))
+
+(defn ^:private parse-schema*
+  [^Schema$Parser parser source]
+  (if (instance? String source)
+    (.parse parser ^String source)
+    (.parse parser ^InputStream source)))

 (defn parse-schema
   "Parse Avro schemas in `sources`.  Each schema source may be a JSON
@@ -71,23 +88,23 @@
                   (when (named-schema? source)
                     (.addTypes parser {(.getFullName ^Schema source) source})))
                 (->> (if (raw-schema? source) source (clj->json source))
-                     (.parse parser))))
+                     (parse-schema* parser))))
             nil
             sources)))

 (defn datum-reader
   "Return an Avro DatumReader which produces Clojure data structures."
-  {:tag 'abracad.avro.ClojureDatumReader}
+  {:tag `ClojureDatumReader}
   ([] (ClojureDatumReader.))
   ([schema] (ClojureDatumReader. schema))
   ([expected actual] (ClojureDatumReader. expected actual)))

 (defn data-file-reader
   "Return an Avro DataFileReader which produces Clojure data structures."
-  {:tag 'org.apache.avro.file.DataFileReader}
+  {:tag `DataFileReader}
   ([source] (data-file-reader nil source))
   ([expected source]
-     (DataFileReader. (sink-for source) (datum-reader expected))))
+     (DataFileReader/openReader (source-for source) (datum-reader expected))))

 (defmacro ^:private decoder-factory
   "Invoke static methods of default Avro Decoder factory."
@@ -96,22 +113,27 @@
 (defn binary-decoder
   "Return a binary-encoding decoder for `source`.  The `source` may be
 an input stream, a byte array, or a vector of `[bytes off len]`."
-  {:tag 'org.apache.avro.io.Decoder}
+  {:tag `Decoder}
   [source]
-  (if-not (vector? source)
-    (decoder-factory binaryDecoder source nil)
+  (if (vector? source)
     (let [[source off len] source]
-      (decoder-factory binaryDecoder source off len nil))))
+      (decoder-factory binaryDecoder source off len nil))
+    (if (instance? InputStream source)
+      (decoder-factory binaryDecoder ^InputStream source nil)
+      (decoder-factory binaryDecoder ^bytes source nil))))

 (defn direct-binary-decoder
   "Return a non-buffered binary-encoding decoder for `source`."
-  {:tag 'org.apache.avro.io.Decoder}
+  {:tag `Decoder}
   [source] (decoder-factory directBinaryDecoder source nil))

 (defn json-decoder
   "Return a JSON-encoding decoder for `source` using `schema`."
-  {:tag 'org.apache.avro.io.Decoder}
-  [schema source] (decoder-factory jsonDecoder schema source))
+  {:tag `Decoder}
+  [schema source]
+  (if (instance? InputStream source)
+    (decoder-factory jsonDecoder ^Schema schema ^InputStream source)
+    (decoder-factory jsonDecoder ^Schema schema ^String source)))

 (defn ^:private coerce
   "Coerce `x` to be of class `c` by applying `f` to it iff `x` isn't
@@ -142,20 +164,25 @@

 (defn datum-writer
   "Return an Avro DatumWriter which consumes Clojure data structures."
-  {:tag 'abracad.avro.ClojureDatumWriter}
+  {:tag `ClojureDatumWriter}
   ([] (ClojureDatumWriter.))
   ([schema] (ClojureDatumWriter. schema)))

 (defn data-file-writer
   "Return an Avro DataFileWriter which consumes Clojure data structures."
-  {:tag 'org.apache.avro.file.DataFileWriter}
+  {:tag `DataFileWriter}
   ([] (DataFileWriter. (datum-writer)))
-  ([sink] (doto (data-file-writer) (.appendTo (sink-for sink))))
-  ([schema sink] (data-file-writer nil schema sink))
+  ([sink]
+     (let [^DataFileWriter dfw (data-file-writer)]
+       (doto dfw (.appendTo (io/file sink)))))
+  ([schema sink]
+     (data-file-writer nil schema sink))
   ([codec schema sink]
-     (let [writer (data-file-writer)]
+     (let [^DataFileWriter writer (data-file-writer)]
        (when codec (.setCodec writer (codec-for codec)))
-       (.create writer schema (sink-for sink))
+       (if (instance? OutputStream)
+         (.create writer ^Schema schema ^OutputStream sink)
+         (.create writer ^Schema schema (io/file sink)))
        writer)))

 (defmacro ^:private encoder-factory
@@ -164,18 +191,19 @@

 (defn binary-encoder
   "Return a binary-encoding encoder for `sink`."
-  {:tag 'org.apache.avro.io.Encoder}
+  {:tag `Encoder}
   [sink] (encoder-factory binaryEncoder sink nil))

 (defn direct-binary-encoder
   "Return an unbuffered binary-encoding encoder for `sink`."
-  {:tag 'org.apache.avro.io.Encoder}
+  {:tag `Encoder}
   [sink] (encoder-factory directBinaryEncoder sink nil))

 (defn json-encoder
   "Return a JSON-encoding encoder for `sink` using `schema`."
-  {:tag 'org.apache.avro.io.Encoder}
-  [schema sink] (encoder-factory jsonEncoder schema sink))
+  {:tag `Encoder}
+  [schema sink]
+  (encoder-factory jsonEncoder ^Schema schema ^OutputStream sink))

 (defn encode
   "Serially encode each record in `records` to `sink` using `schema`.


function composition

function composition

error: pathspec 'src/sandbox/fbuilder/composition.clj' did not match any file(s) known to git

--- src/sandbox/fbuilder/composition.clj
+++ src/sandbox/fbuilder/composition.clj
@@ -0,0 +1,24 @@
+(ns sandbox.fbuilder.composition)
+
+(def request
+  {:headers
+   {"Authorization" "auth"
+    "X-RequestFingerprint" "fingerprint"}
+   :body "body"})
+
+(defn check-authorization [request]
+  (let [auth-header (get-in request [:headers "Authorization"])]
+    (assoc
+     request
+     :principal
+     (if-not (nil? auth-header) "AUser"))))
+
+(defn log-fingerprint [request]
+  (let [fingerprint (get-in request [:headers "X-RequestFingerprint"])]
+    (println (str "FINGERPRINT=" fingerprint))
+    request))
+
+(defn compose-filters [filters]
+  (apply comp filters))
+
+(def filter-chain (compose-filters [check-authorization log-fingerprint]))


A helpful file.

A helpful file.

error: pathspec 'src/midje/util/ecosystem.clj' did not match any file(s) known to git

--- src/midje/util/ecosystem.clj
+++ src/midje/util/ecosystem.clj
@@ -0,0 +1,7 @@
+;; -*- indent-tabs-mode: nil -*-
+
+(ns midje.util.ecosystem)
+
+(def issues-url
+     "https://github.com/marick/Midje/issues")
+


add new overtone.helpers.map ns

add new overtone.helpers.map ns

error: pathspec 'src/overtone/helpers/map.clj' did not match any file(s) known to git

--- src/overtone/helpers/map.clj
+++ src/overtone/helpers/map.clj
@@ -0,0 +1,15 @@
+(ns
+    ^{:doc "Helper functions for manipulating maps"
+      :author "Sam Aaron"}
+  overtone.helpers.map)
+
+(defn reverse-get
+  "Returns the key of the first val in maps vals that equals
+  v. Non-deterministic if (vals m) contains duplicates and map isn't
+  sorted."
+  [m v]
+  (let [f (first m)
+        n (next m)]
+    (if (= (val f) v)
+      (key f)
+      (when n (reverse-get n v)))))


Start work on rss feed module

Start work on rss feed module

error: pathspec 'src/braid/rss/core.cljc' did not match any file(s) known to git

--- src/braid/rss/core.cljc
+++ src/braid/rss/core.cljc
@@ -0,0 +1,81 @@
+(ns braid.rss.core
+  "Extension to post updates from RSS feeds as messages in a given group"
+  (:require
+   [braid.core.core :as core]
+   #?@(:clj
+       [[braid.core.server.db :as db]
+        [clj-time.format :as f]
+        [clojure.string :as string]
+        [clojure.xml :as xml]
+        [clojure.walk :as walk]
+        [datomic.api :as d]
+        [datomic.db]
+        [org.httpkit.client :as http]])))
+
+(defn parse-item
+  [item]
+  (-> (reduce (fn [m {:keys [tag content]}]
+                (assoc m tag (string/join "" content)))
+              {} (:content item))
+      (update :pubDate (partial f/parse (f/formatters :rfc822)))
+      (update :description string/trim)))
+
+(defn extract-items
+  [xml]
+  (let [items (atom [])]
+    (walk/postwalk (fn [form]
+                     (if (and (map? form) (= (:tag form) :item))
+                       (do (swap! items conj (parse-item form))
+                           nil)
+                       form))
+                   xml)
+    @items))
+
+(defn fetch-feed
+  [url]
+  (->> @(http/get url)
+      :body
+      .getBytes
+      (java.io.ByteArrayInputStream.)
+      xml/parse
+      extract-items))
+
+(defn item-guid
+  [item]
+  (or (:guid item)
+      (->> ((apply juxt (sort (keys item))) item)
+          (string/join "")
+          hash str)))
+
+(defn update-feed!
+  [feed-url]
+  (->> (fetch-feed feed-url)
+      (sort-by :pubDate #(compare %2 %1))
+      first))
+
+(defn init!
+  []
+  #?(:clj
+     (do
+       (core/register-db-schema!
+         [{:db/ident :rss/id
+           :db/valueType :db.type/uuid
+           :db/cardinality :db.cardinality/one
+           :db/unique :db.unique/identity
+           :db/id #db/id[:db.part/db]
+           :db.install/_attribute :db.part/db}
+          {:db/ident :rss/group
+           :db/valueType :db.type/ref
+           :db/cardinality :db.cardinality/one
+           :db/db #db/id[:db.part/db]
+           :db.install/_attribute :db.part/db}
+          {:db/ident :rss/feed-url
+           :db/valueType :db.type/string
+           :db/cardinality :db.cardinality/one
+           :db/id #db/id[:db.part/db]
+           :db.install/_attribute :db.part/db}
+          {:db/ident :rss/last-fetched
+           :db/valueType :db.type/string
+           :db/cardinality :db.cardinality/one
+           :db/id #db/id[:db.part/db]
+           :db.install/_attribute :db.part/db}]))))


get start date and end date of calendar

get start date and end date of calendar

remote: Support for password authentication was removed on August 13, 2021.
remote: Please see https://docs.github.com/en/get-started/getting-started-with-git/about-remote-repositories#cloning-with-https-urls for information on currently recommended modes of authentication.
fatal: Authentication failed for 'https://github.com/dagda1/i-cal.git/'


add bubble

add bubble

error: pathspec 'src/bluebell/bubble/core.clj' did not match any file(s) known to git

--- src/bluebell/bubble/core.clj
+++ src/bluebell/bubble/core.clj
@@ -0,0 +1,18 @@
+(ns bluebell.bubble)
+
+(defn bubble [x]
+  [::bubble x])
+
+(defn bubble? [x]
+  (and (vector? x)
+       (= ::bubble (first x))))
+
+(defn break [x]
+  (assert (bubble? x))
+  (second x))
+
+(defn protect-fn [f]
+  (fn [& args]
+    (or (first (filter bubble? args))
+        (apply f args))))
+


add some docs for the util namespace

add some docs for the util namespace

remote: Support for password authentication was removed on August 13, 2021.
remote: Please see https://docs.github.com/en/get-started/getting-started-with-git/about-remote-repositories#cloning-with-https-urls for information on currently recommended modes of authentication.
fatal: Authentication failed for 'https://github.com/wilkerlucio/youtube-looper.git/'


Adding macro to clean the code

Adding macro to clean the code

remote: Support for password authentication was removed on August 13, 2021.
remote: Please see https://docs.github.com/en/get-started/getting-started-with-git/about-remote-repositories#cloning-with-https-urls for information on currently recommended modes of authentication.
fatal: Authentication failed for 'https://github.com/iot-paas-home/telegram-iot-gateway.git/'


remove extra set of parens.

remove extra set of parens.

--- src/metabase/api/meta/db.clj
+++ src/metabase/api/meta/db.clj
@@ -44,11 +44,11 @@
 (defendpoint POST "/validate" [:as {{:keys [host port]} :body}]
   {host Required
    port Required}
-  ((let [response-invalid (fn [m] {:status 400 :body {:valid false :message m}})]
+  (let [response-invalid (fn [m] {:status 400 :body {:valid false :message m}})]
     (cond
       (u/host-port-up? host port) {:valid true}
       (u/host-up? host)           (response-invalid "Invalid port")
-      :else                       (response-invalid "Host not reachable")))))
+      :else                       (response-invalid "Host not reachable"))))

 (defendpoint GET "/:id" [id]
   (->404 (sel :one Database :id id)


Berrizendatu

Berrizendatu

remote: Support for password authentication was removed on August 13, 2021.
remote: Please see https://docs.github.com/en/get-started/getting-started-with-git/about-remote-repositories#cloning-with-https-urls for information on currently recommended modes of authentication.
fatal: Authentication failed for 'https://github.com/lnmnd/magnet.zer.git/'


Make sure drivers get loaded at some point :yum:

--- src/metabase/driver.clj
+++ src/metabase/driver.clj
@@ -1,7 +1,9 @@
 (ns metabase.driver
-  (:require [clojure.math.numeric-tower :as math]
+  (:require [clojure.java.classpath :as classpath]
+            [clojure.math.numeric-tower :as math]
             [clojure.string :as s]
             [clojure.tools.logging :as log]
+            [clojure.tools.namespace.find :as ns-find]
             [korma.core :as k]
             [medley.core :as m]
             [metabase.db :refer [ins sel upd]]
@@ -229,9 +231,17 @@
   (swap! registered-drivers assoc engine driver-instance)
   (log/debug (format "Registered driver %s." engine)))

+(def ^:private load-driver-namespaces!
+  "Search the classpath for metabase driver namespaces and `require` them, so they are \"registered\" and can be used :heart_eyes_cat:"
+  (delay (doseq [namespce (filter (fn [ns-symb]
+                                    (re-matches #"^metabase\.driver\.[a-z0-9_]+$" (name ns-symb)))
+                                  (ns-find/find-namespaces (classpath/classpath)))]
+           (require namespce))))
+
 (defn available-drivers
   "Info about available drivers."
   []
+  @load-driver-namespaces!
   (m/map-vals (fn [driver]
                 {:details-fields (details-fields driver)
                  :driver-name    (name driver)


Fetishistically protect from nil.

Fetishistically protect from nil.

remote: Support for password authentication was removed on August 13, 2021.
remote: Please see https://docs.github.com/en/get-started/getting-started-with-git/about-remote-repositories#cloning-with-https-urls for information on currently recommended modes of authentication.
fatal: Authentication failed for 'https://github.com/mtravers/incidents.git/'


Move definition of GlobalEnv type to work in progress

Having a type that separates system-provided definitions from the ones
made by the user would be the cleanest solution to provide
visualizations only with data entered by the user.  However, since
Clojure makes it quite awkward to define new collections (and we have to
repeat the exercise for ClojureScript) we'll just dissociate the known
global data from the current global environment when passing data to
visualizations.

error: pathspec 'src/wip/global-env.cljx' did not match any file(s) known to git

--- src/wip/global-env.cljx
+++ src/wip/global-env.cljx
@@ -0,0 +1,355 @@
+;;; Work in progress that didn't make it into the code base, yet.
+
+;;; Global Environments
+;;; ===================
+
+;;; We need to be able to easily separate functions defined by the
+;;; user from those defined by the system or by libraries, and we need
+;;; to do so rather frequently.  So rather than filtering a flat
+;;; global environment for every step of the trace we define a type
+;;; `GlobalEnv` that contains two maps: `system-env` and `user-env`.
+;;; Lookups generally take place in both maps, but we are only
+;;; interested in user-defined function (which we usually are for
+;;; visualization purposes), we can easily detach the user
+;;; environment.
+
+(defprotocol IGlobalEnv
+  "The protocol for global environments: return the system and the
+  user environment."
+  (system-env [this])
+  (user-env [this]))
+
+(declare ->GlobalEnv)
+(def ^:dynamic *defining-system-env*
+  "If truthy, make global changes to `GlobalEnv` instances in their
+  system environment, otherwise change their user environment."
+  false)
+
+;;; Implementing Map-Like Datatypes
+;;; -----------------------------
+
+;;; Since the implementation of datatypes that work like maps and
+;;; sequences is, as far as I know, not well documented in the Clojure
+;;; literature, I've included an overview of the class hierarchy.  In
+;;; Clojure, the necessary interfaces are defined in Java and can be
+;;; found in the `clojure.lang` namespace, in the directory
+;;; `clojure/src/jvm/clojure/lang`.  The "protocols" are implemented
+;;; as Java interfaces, so they are not available as protocols for
+;;; Clojure code outside the `deftype` macro.  So you can't evaluate
+;;; either of
+;;;
+;;;     (satisfies? Counted {})              ;; BAD
+;;;     (satisfies? clojure.lang.Counted {}) ;; BAD
+;;;     (satisfies? clojure.lang/Counted {}) ;; BAD
+;;;
+;;; to check whether something implements the `Counted` protocol, since
+;;; all three forms will throw an exception for any Clojure object.
+
+;;; The abstract implementation of a map is `APersistentMap` which
+;;; extends the class `AFn` and implements the interfaces
+;;; `IPersistentMap`, `Map`, `Iterable`, `Serializable`,
+;;; `MapEquivalence` and `IHashEq`.  The following table gives an
+;;; overview of the inheritance hierarchy and methods implemented:
+
+;;; ```
+;;; AFn:                   IFn
+;;; IFn:                   Callable, Runnable
+;;;   invoke
+;;; IPersistentMap:        Iterable, Associative, Counted
+;;;   assoc
+;;;   assocEx
+;;;   without
+;;; Iterable:
+;;;   iterator
+;;; Associative:           IPersistentCollection, ILookup
+;;;   containsKey
+;;;   entryAt
+;;;   assoc
+;;; IPersistentCollection: Seqable
+;;;   count
+;;;   cons
+;;;   empty
+;;;   equiv
+;;; ILookup:
+;;;   valAt
+;;; Seqable:
+;;;   seq
+;;; Counted:
+;;;   count
+;;; Map: (required methods only)
+;;;   containsKey
+;;;   containsValue
+;;;   entrySet
+;;;   equals
+;;;   get
+;;;   hashCode
+;;;   isEmpty
+;;;   keySet
+;;;   size
+;;;   values
+;;; Serializable:
+;;;   writeObject
+;;;   readObject
+;;;   readObjectNoData
+;;; MapEquivalence:
+;;; IHashEq
+;;;   hasheq
+;;;```
+
+;;; The handling of equality and hashes is a bit complicated because
+;;; it relies on implementation internals.
+;;; See [these](http://dev.clojure.org/jira/browse/CLJ-1301)
+;;; [links](http://dev.clojure.org/jira/browse/CLJ-1364)
+;;; [to](http://dev.clojure.org/jira/browse/CLJ-1070)
+;;; [discussions](http://dev.clojure.org/jira/browse/CLJ-1059) about
+;;; the issue.  My current understanding is that there are two
+;;; implementations of equality/hashing that the Clojure compiler uses
+;;; in differenct circumstances: `equals`/`hashEq` is the Java
+;;; implementation of equality/hashing; `equiv`/`hasheq` is the
+;;; Clojure one.
+
+#+clj
+(deftype GlobalEnv [system-env user-env]
+  IGlobalEnv
+  (system-env [this]
+    system-env)
+  (user-env [this]
+    user-env)
+  clojure.lang.IHashEq
+  (hasheq [this]
+    (hash-combine system-env user-env))
+  clojure.lang.MapEquivalence
+  java.io.Serializable
+  java.util.Map
+  (containsKey [this key]
+    (or (.containsKey system-env key)
+        (.containsKey user-env key)))
+  (containsValue [this val]
+    (boolean (or (.containsValue system-env)
+                 (.containsValue user-env))))
+  (entrySet [this]
+    (clojure.set/union (.entrySet system-env) (.entrySet user-env)))
+  (equals [this other]
+    ;; Pass this on to `equiv`
+    (= this other))
+  (get [this key]
+    (or (get user-env key)
+        (get system-env key)))
+  (hashCode [this]
+    ;; Not sure how this should relate to IHashEq above.  My
+    ;; understanding is that the Java hash is used in situations where
+    ;; performance is important and the type can be statically
+    ;; determined(?). Returning the
+    ;; same value from both should be safe, though, if `equals` and
+    ;; `equiv` (corresponding to Clojure `=`) are implemented in the
+    ;; same way.
+    (.hasheq this))
+  (isEmpty [this]
+    (and (= 0 (count system-env)) (= 0 (count user-env))))
+  (keySet [this]
+    (clojure.set/union (set (keys system-env)) (set (keys user-env))))
+  (size [this]
+    (+ (count system-env) (count user-env)))
+  (values [this]
+    (concat (vals system-env) (vals user-env)))
+  clojure.lang.Associative
+  clojure.lang.IPersistentCollection
+  (clojure.core/equiv [this other]
+    (boolean
+     (or (identical? this other)
+         (when (identical? (class this) (class other))
+           (and
+            (= system-env (. other -system-env))
+            (= user-env (. other -user-env))))))))
+
+;;; For reference, this is the macro-expansion of a `defrecord` form
+;;; containing user-env and system-env fields.
+
+#_
+(let []
+  (deftype*
+    GlobalEnv
+    revue.util.GlobalEnv
+    [system-env user-env __meta __extmap]
+    :implements
+    [IGlobalEnv
+     clojure.lang.IRecord
+     clojure.lang.IHashEq
+     clojure.lang.IObj
+     clojure.lang.ILookup
+     clojure.lang.IKeywordLookup
+     clojure.lang.IPersistentMap
+     java.util.Map
+     java.io.Serializable]
+    (clojure.core/entrySet
+      [this__5942__auto__]
+      (set this__5942__auto__))
+    (clojure.core/values
+      [this__5941__auto__]
+      (vals this__5941__auto__))
+    (clojure.core/keySet
+      [this__5940__auto__]
+      (set (keys this__5940__auto__)))
+    (clojure.core/clear
+      [this__5939__auto__]
+      (throw (java.lang.UnsupportedOperationException.)))
+    (clojure.core/putAll
+      [this__5937__auto__ m__5938__auto__]
+      (throw (java.lang.UnsupportedOperationException.)))
+    (remove
+      [this__5935__auto__ k__5936__auto__]
+      (throw (java.lang.UnsupportedOperationException.)))
+    (clojure.core/put
+      [this__5932__auto__ k__5933__auto__ v__5934__auto__]
+      (throw (java.lang.UnsupportedOperationException.)))
+    (get
+      [this__5930__auto__ k__5931__auto__]
+      (.valAt this__5930__auto__ k__5931__auto__))
+    (clojure.core/containsValue
+      [this__5928__auto__ v__5929__auto__]
+      (boolean (some #{v__5929__auto__} (vals this__5928__auto__))))
+    (clojure.core/isEmpty
+      [this__5927__auto__]
+      (= 0 (.count this__5927__auto__)))
+    (clojure.core/size
+      [this__5926__auto__]
+      (.count this__5926__auto__))
+    (clojure.core/without
+      [this__5924__auto__ k__5925__auto__]
+      (if (contains? #{:user-env :system-env} k__5925__auto__)
+        (dissoc
+          (with-meta (into {} this__5924__auto__) __meta)
+          k__5925__auto__)
+        (new
+          GlobalEnv
+          system-env
+          user-env
+          __meta
+          (not-empty (dissoc __extmap k__5925__auto__)))))
+    (assoc
+      [this__5922__auto__ k__5923__auto__ G__10330]
+      (condp identical? k__5923__auto__
+        :system-env (new GlobalEnv G__10330 user-env __meta __extmap)
+        :user-env (new GlobalEnv system-env G__10330 __meta __extmap)
+        (new
+          GlobalEnv
+          system-env
+          user-env
+          __meta
+          (assoc __extmap k__5923__auto__ G__10330))))
+    (clojure.core/iterator
+      [this__5921__auto__]
+      (clojure.lang.SeqIterator. (.seq this__5921__auto__)))
+    (seq
+      [this__5920__auto__]
+      (seq
+        (concat
+          [(new clojure.lang.MapEntry :system-env system-env)
+           (new clojure.lang.MapEntry :user-env user-env)]
+          __extmap)))
+    (clojure.core/entryAt
+      [this__5916__auto__ k__5917__auto__]
+      (let [v__5918__auto__ (.valAt
+                              this__5916__auto__
+                              k__5917__auto__
+                              this__5916__auto__)]
+        (when-not (identical? this__5916__auto__ v__5918__auto__)
+          (clojure.lang.MapEntry. k__5917__auto__ v__5918__auto__))))
+    (clojure.core/containsKey
+      [this__5914__auto__ k__5915__auto__]
+      (not
+        (identical?
+          this__5914__auto__
+          (.valAt
+            this__5914__auto__
+            k__5915__auto__
+            this__5914__auto__))))
+    (clojure.core/equiv
+      [this__5913__auto__ G__10330]
+      (boolean
+        (or
+          (identical? this__5913__auto__ G__10330)
+          (when (identical?
+                  (class this__5913__auto__)
+                  (class G__10330))
+            (let [G__10330 G__10330]
+              (and
+                (= system-env (. G__10330 -system-env))
+                (= user-env (. G__10330 -user-env))
+                (= __extmap (. G__10330 __extmap))))))))
+    (cons
+      [this__5911__auto__ e__5912__auto__]
+      (#'clojure.core/imap-cons this__5911__auto__ e__5912__auto__))
+    (empty
+      [this__5910__auto__]
+      (throw
+        (java.lang.UnsupportedOperationException.
+          (str "Can't create empty: " "revue.util.GlobalEnv"))))
+    (count [this__5909__auto__] (+ 2 (count __extmap)))
+    (clojure.core/getLookupThunk
+      [this__5907__auto__ k__5908__auto__]
+      (let [gclass (class this__5907__auto__)]
+        (case
+          k__5908__auto__
+          :system-env
+          (reify
+            clojure.lang.ILookupThunk
+            (get
+              [thunk gtarget]
+              (if (identical? (class gtarget) gclass)
+                (. gtarget -system-env)
+                thunk)))
+          :user-env
+          (reify
+            clojure.lang.ILookupThunk
+            (get
+              [thunk gtarget]
+              (if (identical? (class gtarget) gclass)
+                (. gtarget -user-env)
+                thunk)))
+          nil)))
+    (clojure.core/valAt
+      [this__5904__auto__ k__5905__auto__ else__5906__auto__]
+      (case
+        k__5905__auto__
+        :system-env
+        system-env
+        :user-env
+        user-env
+        (get __extmap k__5905__auto__ else__5906__auto__)))
+    (clojure.core/valAt
+      [this__5902__auto__ k__5903__auto__]
+      (.valAt this__5902__auto__ k__5903__auto__ nil))
+    (clojure.core/withMeta
+      [this__5901__auto__ G__10330]
+      (new GlobalEnv system-env user-env G__10330 __extmap))
+    (meta [this__5900__auto__] __meta)
+    (clojure.core/equals
+      [this__5899__auto__ G__10330]
+      (clojure.lang.APersistentMap/mapEquals
+        this__5899__auto__
+        G__10330))
+    (clojure.core/hashCode
+      [this__5898__auto__]
+      (clojure.lang.APersistentMap/mapHash this__5898__auto__))
+    (clojure.core/hasheq
+      [this__5897__auto__]
+      (bit-xor
+        -1798849877
+        (clojure.lang.APersistentMap/mapHasheq this__5897__auto__)))
+    (system-env [this] system-env)
+    (user-env [this] user-env))
+  (import revue.util.GlobalEnv)
+  (defn ->GlobalEnv
+    "Positional factory function for class revue.util.GlobalEnv."
+    [system-env user-env]
+    (new revue.util.GlobalEnv system-env user-env))
+  (defn map->GlobalEnv
+    "Factory function for class revue.util.GlobalEnv, taking a map of keywords to field values."
+    ([m__5999__auto__]
+      (revue.util.GlobalEnv/create
+        (if (instance? clojure.lang.MapEquivalence m__5999__auto__)
+          m__5999__auto__
+          (into {} m__5999__auto__)))))
+  revue.util.GlobalEnv)
+


Removed traces

Removed traces

remote: Support for password authentication was removed on August 13, 2021.
remote: Please see https://docs.github.com/en/get-started/getting-started-with-git/about-remote-repositories#cloning-with-https-urls for information on currently recommended modes of authentication.
fatal: Authentication failed for 'https://github.com/lprefontaine/Boing.git/'


Started new Clojure file

Started new Clojure file

error: pathspec 'clojure/org/gavrog/clojure/ruggero.clj' did not match any file(s) known to git

--- clojure/org/gavrog/clojure/ruggero.clj
+++ clojure/org/gavrog/clojure/ruggero.clj
@@ -0,0 +1,35 @@
+(ns org.gavrog.clojure.ruggero
+  (:use (org.gavrog.clojure
+          [delaney]
+          [delaney2d]
+          [generators :only [results]]
+          [combineTiles :only [combine-tiles]]))
+  (:gen-class))
+
+(def triangle
+  (dsymbol "1.1:6 1:2 4 6,6 3 5:3"))
+
+(def quadrangle
+  (dsymbol "1.1:8 1:2 4 6 8,8 3 5 7:4"))
+
+(defn- orbit-complete? [ds indices D]
+    (empty? (for [D (orbit-elements ds indices [D])
+                  i indices
+                  :when (nil? (s ds i D))] [D i])))
+
+(defn- good-orbit? [ds [i j] D]
+  (or (not (orbit-complete? ds [i j] D))
+      (#{3 4} (r ds i j D))))
+
+(defn- good? [ds]
+  (and (every? #(not= % (s ds 2 %)) (elements ds))
+       (every? (partial good-orbit? ds [1 2]) (orbit-reps ds [1 2]))))
+
+(defn self-dual-3-4-regular [n]
+  (for [i (range (inc (- n 4)))
+        :let [face-list (apply append (concat (repeat 4 triangle)
+                                              (repeat i quadrangle)))]
+        set (results (combine-tiles face-list) (comp good? first))
+        :when (and (self-dual? set) (proto-spherical? set))
+        ]
+    set))


Add snippets for Math - Random. Issue #87.

error: pathspec 'test/snippets/math/random.clj' did not match any file(s) known to git

--- test/snippets/math/random.clj
+++ test/snippets/math/random.clj
@@ -0,0 +1,41 @@
+(ns snippets.math.random
+  (:require [quil.snippet :refer [defsnippet]]
+            [quil.core :refer :all]))
+
+(defsnippet noise-s {}
+  (background 255)
+  (fill 0)
+  (text (str "(noise 42) = " (noise 42)) 10 20)
+  (text (str "(noise 1 2) = " (noise 1 2)) 10 40)
+  (text (str "(noise 50 10 3) = " (noise 50 10 3)) 10 60))
+
+(defsnippet noise-detail-s {}
+  (background 255)
+  (fill 0)
+  (noise-detail 3)
+  (text (str "(noise 42) = " (noise 42)) 10 20)
+  (noise-detail 5 0.5)
+  (text (str "(noise 42) = " (noise 42)) 10 40))
+
+(defsnippet noise-seed-s {}
+  (background 255)
+  (fill 0)
+  (noise-seed 42)
+  (text (str "(noise 42) = " (noise 42)) 10 20))
+
+(defsnippet random-s {}
+  (background 255)
+  (fill 0)
+  (text (str "(random 42) = " (random 42)) 10 20)
+  (text (str "(random Math/E PI) = " (random Math/E PI)) 10 40))
+
+(defsnippet random-gaussian-s {}
+  (background 255)
+  (fill 0)
+  (text (str "(random-gaussian) = " (random-gaussian)) 10 20))
+
+(defsnippet random-seed-s {}
+  (background 255)
+  (fill 0)
+  (random-seed 42)
+  (text (str "(random 42) = " (random 42)) 10 20))


build uri works

build uri works

remote: Support for password authentication was removed on August 13, 2021.
remote: Please see https://docs.github.com/en/get-started/getting-started-with-git/about-remote-repositories#cloning-with-https-urls for information on currently recommended modes of authentication.
fatal: Authentication failed for 'https://github.com/max-neverov/ads-client.git/'


Added registry schema.

Added registry schema.

error: pathspec 'src/dragon/data/schemas/subscriber_registry.clj' did not match any file(s) known to git

--- src/dragon/data/schemas/subscriber_registry.clj
+++ src/dragon/data/schemas/subscriber_registry.clj
@@ -0,0 +1,21 @@
+(ns dragon.data.schemas.subscriber-registry)
+
+(def topic
+  {:db/ident :registry/topic
+   :db/valueType :db.type/keyword
+   :db/cardinality :db.cardinality/one
+   :db/doc "The topic with which the pubsub was created."})
+
+(def tag
+  {:db/ident :registry/tag
+   :db/valueType :db.type/keyword
+   :db/cardinality :db.cardinality/one
+   :db/doc "The tag given to a message."})
+
+(def subscribers
+  {:db/ident :registry/subscribers
+   :db/valueType :db.type/keyword
+   :db/cardinality :db.cardinality/many
+   :db/doc "The subscribers for a message tag."})
+
+(def schema [topic tag subscribers])


Further simplification of Constitutional role validation.

--- spec/freefrog/governance_circles_spec.clj
+++ spec/freefrog/governance_circles_spec.clj
@@ -66,20 +66,16 @@
   (should-not-update-missing-or-empty-roles g/convert-to-role
                                             "convert to role"))

-(defn should-not-change-constitutional [desc fn role-name params]
-  (it (format "doesn't %s the %s role" desc role-name)
-    (should-throw IllegalArgumentException
-      (format "'%s' role is defined in the Constitution." role-name)
-      (apply fn (into [sample-anchor role-name] params)))))
-
 (describe "Constitutional Roles"
   (for [role [g/lead-link g/rep-link g/secretary g/facilitator]
         op [["Add" g/add-role]
             ["Remove" g/remove-role]
             ["Rename" g/rename-role "stuff"]
             ["Update the purpose of" g/update-role-purpose "Stuff"]]]
-    (should-not-change-constitutional (first op) (second op) role
-                                      (drop 2 op))))
+    (it (format "doesn't %s the %s role" (first op) role)
+      (should-throw IllegalArgumentException
+        (format "'%s' role is defined in the Constitution." role)
+        (apply (second op) (into [sample-anchor role] (drop 2 op)))))))

 ;; Section 2.2.3
 (describe "Lead Link Role"


Integration test for ping

Integration test for ping

--- test/ruuvi_server/integration_test/server.clj
+++ test/ruuvi_server/integration_test/server.clj
@@ -1,11 +1,12 @@
 (ns ruuvi-server.integration-test.server
   (:require  [ruuvi-server.database.entities :as entities]
              [ruuvi-server.configuration :as conf]
+             [cheshire.core :as json]
              [clj-http.client :as http])
   (:use [ruuvi-server.launcher :only (start-server migrate)]
         [clojure.tools.logging :only (debug info warn error)]
         [ruuvi-server.database.event-dao]
-        [midje.sweet :only (fact throws)]
+        [midje.sweet :only (fact throws truthy falsey)]
         [clj-time.core :only (date-time)]
         [clj-time.coerce :only (to-timestamp)]
         )
@@ -133,6 +134,27 @@
 (def kill-server (start-server config))
 (info "server started")

+
+(defn http-get [path]
+  (let [no-retry (fn [ex try-count http-context] false)
+        opts {:retry-handler no-retry}]
+    (:body (http/get (str "http://localhost:8888" path) opts))
+    ))
+
+(defn json-get [path]
+  (let [body (http-get path)]
+    (json/parse-string body true)
+    ))
+
+(fact (http-get "/") => truthy)
+(fact (http-get "/api") => truthy)
+(let [pong (json-get "/api/v1-dev/ping")]
+  (prn pong)
+  (fact (:ruuvi-tracker-protocol-version pong) => "1"
+        (:server-software pong) => truthy
+        (:time pong) => truthy)
+  )
+
 (info "stopping server...")
 @(kill-server)
 (info "server stopped")


Stub for test module metadata_analyze

Stub for test module metadata_analyze

error: pathspec 'test/emender_jenkins/metadata_analyzer_test.clj' did not match any file(s) known to git

--- test/emender_jenkins/metadata_analyzer_test.clj
+++ test/emender_jenkins/metadata_analyzer_test.clj
@@ -0,0 +1,29 @@
+;
+;  (C) Copyright 2016  Pavel Tisnovsky
+;
+;  All rights reserved. This program and the accompanying materials
+;  are made available under the terms of the Eclipse Public License v1.0
+;  which accompanies this distribution, and is available at
+;  http://www.eclipse.org/legal/epl-v10.html
+;
+;  Contributors:
+;      Pavel Tisnovsky
+;
+
+(ns emender-jenkins.middleware-test
+  (:require [clojure.test :refer :all]
+            [emender-jenkins.metadata-analyzer :refer :all]))
+
+;
+; Common functions used by tests.
+;
+
+(defn callable?
+    "Test if given function-name is bound to the real function."
+    [function-name]
+    (clojure.test/function? function-name))
+
+;
+; Tests for various function definitions
+;
+


[TH] fix some indentation

[TH] fix some indentation

remote: Support for password authentication was removed on August 13, 2021.
remote: Please see https://docs.github.com/en/get-started/getting-started-with-git/about-remote-repositories#cloning-with-https-urls for information on currently recommended modes of authentication.
fatal: Authentication failed for 'https://github.com/democracyworks/voter-registration-works.git/'


bump CLJS version - how are we going to keep up with this in an automated way?

--- cljs-server/cljsinfo_server/html.cljs
+++ cljs-server/cljsinfo_server/html.cljs
@@ -160,7 +160,7 @@
         [:a {:href github-url} "GitHub" [:i.fa.fa-external-link]]
         [:a {:href issues-url} "JIRA / Issues" [:i.fa.fa-external-link]]]
       [:div.version-eb1a6
-        [:p "Latest: 0.0-2740"]
+        [:p "Latest: 0.0-3196"]
         [:p "Released 4 days ago"]]
       [:div.clr-43e49]
       [:div.bottom-f931d


A terrifying interop example

A terrifying interop example

error: pathspec 'clojure/thread_mess.clj' did not match any file(s) known to git

--- clojure/thread_mess.clj
+++ clojure/thread_mess.clj
@@ -0,0 +1,2 @@
+(dotimes [i 10]
+  (->> (Thread. (fn [] (println (repeat i "*")))) .start))


Remove `go` from `ttl-memoize-async`

Remove `go` from `ttl-memoize-async`

remote: Support for password authentication was removed on August 13, 2021.
remote: Please see https://docs.github.com/en/get-started/getting-started-with-git/about-remote-repositories#cloning-with-https-urls for information on currently recommended modes of authentication.
fatal: Authentication failed for 'https://github.com/democracyworks/turbovote-http-api.git/'


helper functions for running tests

helper functions for running tests

error: pathspec 'test/matross/test/helper.clj' did not match any file(s) known to git

--- test/matross/test/helper.clj
+++ test/matross/test/helper.clj
@@ -0,0 +1,17 @@
+(ns matross.test.helper
+  "Helper functions for writing and running tests"
+  (:require [me.raynes.conch :refer [with-programs]]))
+
+(def running-vms
+  (with-programs [vagrant grep cut]
+    (cut "-f1" "-d "
+         (grep "running"
+               (vagrant "status" {:seq true})
+               {:seq true})
+         {:seq true})))
+
+; need to figure out how to load plugins in the testing phase otherwise we
+; won't be able to load plugins for testing
+(comment defn vm-ssh-connection [name]
+  (with-programs [vagrant]
+    (get-connection (ssh-config-connection (vagrant "ssh-config" name)))))


Clean up test/system

Clean up test/system

remote: Support for password authentication was removed on August 13, 2021.
remote: Please see https://docs.github.com/en/get-started/getting-started-with-git/about-remote-repositories#cloning-with-https-urls for information on currently recommended modes of authentication.
fatal: Authentication failed for 'https://github.com/physion/ovation-webapi.git/'


link to rules,terms,privacy from team editor

remote: Support for password authentication was removed on August 13, 2021.
remote: Please see https://docs.github.com/en/get-started/getting-started-with-git/about-remote-repositories#cloning-with-https-urls for information on currently recommended modes of authentication.
fatal: Authentication failed for 'https://github.com/clojurecup/cc2014-frontend.git/'


use reify for repl-env instead of one-off record

remote: Support for password authentication was removed on August 13, 2021.
remote: Please see https://docs.github.com/en/get-started/getting-started-with-git/about-remote-repositories#cloning-with-https-urls for information on currently recommended modes of authentication.
fatal: Authentication failed for 'https://github.com/modnakasta/weasel.git/'


brepl

brepl

error: pathspec 'src/cljs/modern_cljs/connect.cljs' did not match any file(s) known to git

--- src/cljs/modern_cljs/connect.cljs
+++ src/cljs/modern_cljs/connect.cljs
@@ -0,0 +1,4 @@
+(ns modern-cljs.connect
+  (:require [clojure.browser.repl :as repl]))
+
+(repl/connect "http://localhost:9000/repl")


cleanup

cleanup

remote: Support for password authentication was removed on August 13, 2021.
remote: Please see https://docs.github.com/en/get-started/getting-started-with-git/about-remote-repositories#cloning-with-https-urls for information on currently recommended modes of authentication.
fatal: Authentication failed for 'https://github.com/clojure-ml/cml.git/'


added jstrength sudoku solution

added jstrength sudoku solution

error: pathspec 'src/main/cljc/clojure_club/sudoku/jstrength.cljc' did not match any file(s) known to git

--- src/main/cljc/clojure_club/sudoku/jstrength.cljc
+++ src/main/cljc/clojure_club/sudoku/jstrength.cljc
@@ -0,0 +1,39 @@
+(ns clojure-club.sudoku.jstrength)
+
+(defn get-candidates [p [x y]]
+  (clojure.set/difference
+    (set (range 1 10))
+    (set
+      (filter
+        (comp not nil?)
+        (concat
+          (let [s (fn [n] (* 3 (quot n 3)))]
+            (for [x (range (s x) (+ (s x) 3))
+                  y (range (s y) (+ 3 (s y)))]
+              (get-in p [x y])))
+          (for [x (range 0 9)]
+            (get-in p [x y]))
+          (for [y (range 0 9)]
+            (get-in p [x y])))))))
+
+(defn calc-candidates [p]
+  (sort-by (comp count second)
+           (for [x (range 0 9)
+                 y (range 0 9)
+                 :when (nil? (get-in p [x y]))
+                 :let [candidates (get-candidates p [x y])]]
+             [[x y] candidates])))
+
+(defn solve
+  ([p] (solve p (calc-candidates p)))
+  ([p [[coord cands] & r]]
+   (if-not coord
+     p
+     (reduce
+       (fn [p cand]
+         (let [new-p (solve (assoc-in p coord cand))]
+           (if (every? (comp not nil?) (flatten new-p))
+             (reduced new-p)
+             p)))
+       p
+       cands))))


Seems to be ignoring CLI args in production; hard-coding nrepl port.

--- src/clojars/main.clj
+++ src/clojars/main.clj
@@ -27,6 +27,6 @@
   (start-jetty)
   (start-nailgun)
   (when-let [port (config :nrepl-port)]
-    (nrepl/start-server :port port)))
+    (nrepl/start-server :port 7991 :bind "127.0.0.1")))

 ; (defonce server (run-jetty #'clojars-app {:port 8080 :join? false}))


Factored retry settings into one place

Factored retry settings into one place

And added a comment detailing the max time it will spend retrying.

remote: Support for password authentication was removed on August 13, 2021.
remote: Please see https://docs.github.com/en/get-started/getting-started-with-git/about-remote-repositories#cloning-with-https-urls for information on currently recommended modes of authentication.
fatal: Authentication failed for 'https://github.com/democracyworks/scheduled-message-works.git/'


add new sound module to utils for webaudio

error: pathspec 'src/cljs/infinitelives/utils/sound.cljs' did not match any file(s) known to git

--- src/cljs/infinitelives/utils/sound.cljs
+++ src/cljs/infinitelives/utils/sound.cljs
@@ -0,0 +1,38 @@
+(ns infinitelives.utils.sound
+  (:require [cljs.core.async :refer [put! chan <! >! alts! timeout close!]]
+            ))
+
+(def audio-context (if js/window.AudioContext (js/window.AudioContext.) (js/window.webkitAudioContext.)))
+
+(def default-gain 0.7)
+
+(defn load-sound
+  "Initiates a download of the url as a sound. Returns a channel.
+  When loaded and decoded, sends a decoded buffer object down the
+  channel. This buffer can be used directly as a sound source"
+  [url]
+  (let [req (js/XMLHttpRequest.)
+        c (chan)]
+    (.open req "GET" url true)
+    (set! (.-responseType req) "arraybuffer")
+    (set! (.-onload req) (fn [] (.decodeAudioData audio-context (.-response req) #(put! c %))))
+    (.send req)
+    c))
+
+(defn play-sound
+  "pass this a buffer, and an optional gain parameter, and the
+  sound will be played to the speakers"
+  ([buff g & [loop-flag]]
+   (let [source (.createBufferSource audio-context)
+         gain (.createGain audio-context)]
+     (if loop-flag
+       (set! (.-loop source) true)
+       (set! (.-loop source) false))
+     (set! (.-buffer source) buff)
+     (.connect source gain)
+     (.connect gain (.-destination audio-context))
+     (set! (.-gain.value gain) g)
+     (.start source 0)
+     [source gain]))
+  ([buff]
+   (play-sound buff default-gain)))


Moved repl code to demo. Updated core to run with main. Added better exit handling for command line running

error: pathspec 'src/life/demo.clj' did not match any file(s) known to git

--- src/life/demo.clj
+++ src/life/demo.clj
@@ -0,0 +1,70 @@
+(ns life.demo
+  (:use [clojure.core.matrix]
+        [life.matrix]
+        [life.display]
+        [life.pic])
+  (:require [clojure.core.matrix.operators :as m]))
+
+(range 9)
+
+(reshape (array (range 9)) [3 3])
+
+(def init #{1 2 3 4 7})
+
+(def r (emap (nbool init) (reshape (array (range 9)) [3 3])))
+
+(takeof [5 7] r)
+
+(def R (rotate (rotate (takeof [5 7] r) 1 -2) 0 -1))
+
+(map #(rotate %2 1 %1) [1 0 -1] [R R R])
+(map #(rotate %2 1 %1) [1 0 -1] (repeat R))
+
+(map (fn [d] (map #(rotate %2 0 %1) [1 0 -1] (repeat d)))
+     (map #(rotate %2 1 %1) [1 0 -1] (repeat R)))  ;; transposed from video
+
+;; more direct would be:
+;; (disp (apply add (for [y [1 0 -1] x [1 0 -1]] (rotate (rotate R 1 x) 0 y))))
+;; (disp (map (=x (apply add (for [y [1 0 -1] x [1 0 -1]] (rotate (rotate R 1 x) 0 y)))) [3 4]))
+
+(def grid ((outer-fn rotate [1 0 -1] [1 0 -1]) R))
+
+;; slices does rows, then columns, while APL explicitly selected columns, then rows
+;; dimensional slice selection is still TODO in core.matrix
+(disp (map (partial apply add) (slices grid)))
+(disp (apply add (map (partial apply add) (slices grid))))
+
+(disp (map (=x (apply add (map (partial apply add) (slices grid)))) [3 4]))
+
+(disp (map and* [1 R] (map (=x (apply add (map (partial apply add) (slices grid)))) [3 4])))
+
+(disp (apply or* (map and*
+                      [1 R]
+                      (map (=x (apply add (map (partial apply add)
+                                               (slices ((outer-fn rotate [1 0 -1] [1 0 -1]) R)))))
+                           [3 4]))))
+
+;; so here is the life function
+(defn life [o]
+  (apply or*
+         (map and*
+              [1 o]
+              (map (=x (apply add (map (partial apply add)
+                                       (slices ((outer-fn rotate [1 0 -1] [1 0 -1]) o)))))
+                   [3 4]))))
+
+(defn gen [o g] ((power life g) o))
+
+(disp (map (partial gen R) (range 4)))
+
+(def RR (rotate (rotate (takeof [15 35] R) 1 20) 0 10))
+
+(defn draw-life [o]
+  (let [r (life o)]
+    (draw (pic r))
+    (Thread/sleep 125)
+    r))
+
+(open-window)
+(power-limit draw-life RR)
+


add the unit test for testing4j

add the unit test for testing4j

error: pathspec 'test/clj/backtype/storm/testing4j_test.clj' did not match any file(s) known to git

--- test/clj/backtype/storm/testing4j_test.clj
+++ test/clj/backtype/storm/testing4j_test.clj
@@ -0,0 +1,144 @@
+(ns backtype.storm.testing4j-test
+  (:use [clojure.test])
+  (:use [backtype.storm config clojure testing])
+  (:require [backtype.storm.integration-test :as it])
+  (:require [backtype.storm.thrift :as thrift])
+  (:import [backtype.storm Testing Config ILocalCluster])
+  (:import [backtype.storm.tuple Values])
+  (:import [backtype.storm.utils Time Utils])
+  (:import [backtype.storm.testing MkClusterParam TestJob MockedSources TestWordSpout
+            TestWordCounter TestGlobalCount TestAggregatesCounter CompleteTopologyParam
+            AckFailMapTracker]))
+
+(deftest test-with-simulated-time
+  (is (= false (Time/isSimulating)))
+  (Testing/withSimulatedTime (fn []
+                               (is (= true (Time/isSimulating)))))
+  (is (= false (Time/isSimulating))))
+
+(deftest test-with-local-cluster
+  (let [mk-cluster-param (doto (MkClusterParam.)
+                           (.setSupervisors (int 2))
+                           (.setPortsPerSupervisor (int 5)))
+        daemon-conf (doto (Config.)
+                      (.put SUPERVISOR-ENABLE false)
+                      (.put TOPOLOGY-ACKER-EXECUTORS 0))]
+    (Testing/withLocalCluster mk-cluster-param (reify TestJob
+                                                 (^void run [this ^ILocalCluster cluster]
+                                                   (is (not (nil? cluster)))
+                                                   (is (not (nil? (.getState cluster))))
+                                                   (is (not (nil? (:nimbus (.getState cluster))))))))))
+
+(deftest test-with-simulated-time-local-cluster
+  (let [mk-cluster-param (doto (MkClusterParam.)
+                           (.setSupervisors (int 2)))
+        daemon-conf (doto (Config.)
+                      (.put SUPERVISOR-ENABLE false)
+                      (.put TOPOLOGY-ACKER-EXECUTORS 0))]
+    (is (not (Time/isSimulating)))
+    (Testing/withSimulatedTimeLocalCluster mk-cluster-param (reify TestJob
+                                                              (^void run [this ^ILocalCluster cluster]
+                                                                (is (not (nil? cluster)))
+                                                                (is (not (nil? (.getState cluster))))
+                                                                (is (not (nil? (:nimbus (.getState cluster)))))
+                                                                (is (Time/isSimulating)))))
+    (is (not (Time/isSimulating)))))
+
+(deftest test-complete-topology
+  (doseq [zmq-on? [true false]
+          :let [daemon-conf (doto (Config.)
+                              (.put STORM-LOCAL-MODE-ZMQ zmq-on?))
+                mk-cluster-param (doto (MkClusterParam.)
+                                   (.setSupervisors (int 4))
+                                   (.setDaemonConf daemon-conf))]]
+    (Testing/withSimulatedTimeLocalCluster
+     (reify TestJob
+       (^void run [this ^ILocalCluster cluster]
+         (let [topology (thrift/mk-topology
+                         {"1" (thrift/mk-spout-spec (TestWordSpout. true) :parallelism-hint 3)}
+                         {"2" (thrift/mk-bolt-spec {"1" ["word"]} (TestWordCounter.) :parallelism-hint 4)
+                          "3" (thrift/mk-bolt-spec {"1" :global} (TestGlobalCount.))
+                          "4" (thrift/mk-bolt-spec {"2" :global} (TestAggregatesCounter.))
+                          })
+               mocked-sources (doto (MockedSources.)
+                                (.addMockData "1" (into-array Values [(Values. (into-array ["nathan"]))
+                                                                      (Values. (into-array ["bob"]))
+                                                                      (Values. (into-array ["joey"]))
+                                                                      (Values. (into-array ["nathan"]))])
+                                              ))
+               storm-conf (doto (Config.)
+                            (.setNumWorkers 2))
+               complete-topology-param (doto (CompleteTopologyParam.)
+                                         (.setMockedSources mocked-sources)
+                                         (.setStormConf storm-conf))
+               results (Testing/completeTopology cluster
+                                                 topology
+                                                 complete-topology-param)]
+           (is (Testing/eq [["nathan"] ["bob"] ["joey"] ["nathan"]]
+                           (Testing/readTuples results "1")))
+           #_(is (ms= [["nathan" 1] ["nathan" 2] ["bob" 1] ["joey" 1]]
+                      (read-tuples results "2")))
+           #_(is (= [[1] [2] [3] [4]]
+                    (read-tuples results "3")))
+           #_(is (= [[1] [2] [3] [4]]
+                    (read-tuples results "4")))
+           ))))))
+
+(deftest test-with-tracked-cluster
+  (Testing/withTrackedCluster
+   (reify TestJob
+     (^void run [this ^ILocalCluster cluster]
+       (let [[feeder checker] (it/ack-tracking-feeder ["num"])
+             tracked (Testing/mkTrackedTopology
+                      cluster
+                      (topology
+                       {"1" (spout-spec feeder)}
+                       {"2" (bolt-spec {"1" :shuffle} it/identity-bolt)
+                        "3" (bolt-spec {"1" :shuffle} it/identity-bolt)
+                        "4" (bolt-spec
+                             {"2" :shuffle
+                              "3" :shuffle}
+                             (it/agg-bolt 4))}))]
+         (Testing/submitLocalTopology cluster
+                                      "test-acking2"
+                                      (Config.)
+                                      (.getTopology tracked))
+         (.feed feeder [1])
+         (Testing/trackedWait tracked (int 1))
+         (checker 0)
+         (.feed feeder [1])
+         (Testing/trackedWait tracked (int 1))
+         (checker 2)
+         )))))
+
+(deftest test-advance-cluster-time
+  (let [daemon-conf (doto (Config.)
+                      (.put TOPOLOGY-ENABLE-MESSAGE-TIMEOUTS true))
+        mk-cluster-param (doto (MkClusterParam.)
+                           (.setDaemonConf daemon-conf))]
+    (Testing/withSimulatedTimeLocalCluster
+     mk-cluster-param
+     (reify TestJob
+       (^void run [this ^ILocalCluster cluster]
+         (let [feeder (feeder-spout ["field1"])
+               tracker (AckFailMapTracker.)
+               _ (.setAckFailDelegate feeder tracker)
+               topology (thrift/mk-topology
+                         {"1" (thrift/mk-spout-spec feeder)}
+                         {"2" (thrift/mk-bolt-spec {"1" :global} it/ack-every-other)})
+               storm-conf (doto (Config.)
+                            (.put TOPOLOGY-MESSAGE-TIMEOUT-SECS 10))]
+           (Testing/submitLocalTopology cluster
+                                        "timeout-tester"
+                                        storm-conf
+                                        topology)
+           (.feed feeder ["a"] 1)
+           (.feed feeder ["b"] 2)
+           (.feed feeder ["c"] 3)
+           (Testing/advanceClusterTime cluster (int 9))
+           (it/assert-acked tracker 1 3)
+           (is (not (.isFailed tracker 2)))
+           (Testing/advanceClusterTime cluster (int 12))
+           (it/assert-failed tracker 2)
+           ))))))
+


Only clojurians who have entered at least a first, last or location display in results.

remote: Support for password authentication was removed on August 13, 2021.
remote: Please see https://docs.github.com/en/get-started/getting-started-with-git/about-remote-repositories#cloning-with-https-urls for information on currently recommended modes of authentication.
fatal: Authentication failed for 'https://github.com/inchingforward/clojurians.git/'


Scrape the stuff from LD

Scrape the stuff from LD

remote: Support for password authentication was removed on August 13, 2021.
remote: Please see https://docs.github.com/en/get-started/getting-started-with-git/about-remote-repositories#cloning-with-https-urls for information on currently recommended modes of authentication.
fatal: Authentication failed for 'https://github.com/f0086/clojurecup2014-luduverse.git/'


Erregistratzean beharrezko eremuak

Erregistratzean beharrezko eremuak

remote: Support for password authentication was removed on August 13, 2021.
remote: Please see https://docs.github.com/en/get-started/getting-started-with-git/about-remote-repositories#cloning-with-https-urls for information on currently recommended modes of authentication.
fatal: Authentication failed for 'https://github.com/lnmnd/magnet.bez.git/'


add missing file

add missing file

error: pathspec 'src/nha/boot_uglify/gzip.clj' did not match any file(s) known to git

--- src/nha/boot_uglify/gzip.clj
+++ src/nha/boot_uglify/gzip.clj
@@ -0,0 +1,45 @@
+(ns nha.boot-uglify.gzip
+  (:require [clojure.java.io :as io]
+            [clojure.string  :as string]
+            [nha.boot-uglify.uglifyjs :as uglify :refer [uglify-str]]
+            [nha.boot-uglify.files-util :refer [delete-target find-assets aggregate total-size compression-details]])
+  (:import
+   [java.io StringWriter FileInputStream FileOutputStream File SequenceInputStream ByteArrayInputStream ByteArrayOutputStream]
+   [javax.script ScriptEngine ScriptEngineManager ScriptException ScriptEngineFactory]
+   [org.apache.commons.lang3 StringEscapeUtils]
+   [java.util.zip GZIPOutputStream]
+   [java.util.logging Level]))
+
+
+(defn str->gzip
+  [str]
+  (^ByteArrayOutputStream with-open [out (ByteArrayOutputStream.)
+                                     gzip (GZIPOutputStream. out)]
+   (do
+     (.write gzip (.getBytes str))
+     (.finish gzip)
+     (.toByteArray out))
+   out))
+
+
+(defn gzip-files
+  "sources"
+  [sources]
+  (^ByteArrayOutputStream str->gzip
+   (->>
+    (map slurp sources)
+    (reduce str))))
+
+
+(defn compress-gzip
+  "compress files or a directory using gzip"
+  [path target {:keys []
+                :or   {}}]
+  (delete-target target)
+  (let [assets (aggregate path "") ;; no specific extension for these
+        {:keys [out error] :as result} (gzip-files assets)]
+    (spit target out)
+    (merge
+     {:errors (if error (list error) '())
+      :warnings '()}
+     (compression-details assets (io/file target)))))


make docstring more accurate

make docstring more accurate

remote: Support for password authentication was removed on August 13, 2021.
remote: Please see https://docs.github.com/en/get-started/getting-started-with-git/about-remote-repositories#cloning-with-https-urls for information on currently recommended modes of authentication.
fatal: Authentication failed for 'https://github.com/jtbeckha/alda.git/'


Added some example data

Added some example data

error: pathspec 'src/tango/data.clj' did not match any file(s) known to git

--- src/tango/data.clj
+++ src/tango/data.clj
@@ -0,0 +1,32 @@
+(ns tango.core
+  (:gen-class)
+  (:require [compojure.core :refer :all] ))
+
+
+(defn gen-data []
+  {
+   :competitions
+   [
+    {
+     :id "<guid1>"
+     :name "SM"
+     :location "Stockholm"
+     :dancers
+     [
+      {
+       :id "<guid2>"
+       :name "kalle"
+       :email "kalle@foo.com"
+      }
+      {
+       :id "<guid3>"
+       :name "kajsa"
+       :email "kajsa@foo.com"
+      }
+     ]
+    }
+   ]
+  }
+ )
+
+(gen-data)


async-as-> properly catches exceptions

async-as-> properly catches exceptions

remote: Support for password authentication was removed on August 13, 2021.
remote: Please see https://docs.github.com/en/get-started/getting-started-with-git/about-remote-repositories#cloning-with-https-urls for information on currently recommended modes of authentication.
fatal: Authentication failed for 'https://github.com/leif47/immutabledb-experimental.git/'


Request perf test

Request perf test

error: pathspec 'perf-test/clj/reitit/request_perf.cljc' did not match any file(s) known to git

--- perf-test/clj/reitit/request_perf.cljc
+++ perf-test/clj/reitit/request_perf.cljc
@@ -0,0 +1,96 @@
+(ns reitit.request-perf
+  (:require [criterium.core :as cc]
+            [reitit.perf-utils :refer :all]
+            [potemkin :as p]))
+
+(set! *warn-on-reflection* true)
+
+;;
+;; start repl with `lein perf repl`
+;; perf measured with the following setup:
+;;
+;; Model Name:            MacBook Pro
+;; Model Identifier:      MacBookPro113
+;; Processor Name:        Intel Core i7
+;; Processor Speed:       2,5 GHz
+;; Number of Processors:  1
+;; Total Number of Cores: 4
+;; L2 Cache (per Core):   256 KB
+;; L3 Cache:              6 MB
+;; Memory:                16 GB
+;;
+
+(defprotocol RawRequest
+  (-uri [this])
+  (-request-method [this])
+  (-path-params [this]))
+
+(p/def-derived-map
+  ZeroCopyRequest
+  [raw]
+  :uri (-uri raw)
+  :request-method (-request-method raw)
+  :path-params (-path-params raw))
+
+(defprotocol RingRequest
+  (get-uri [this])
+  (get-request-method [this])
+  (get-path-params [this]))
+
+(defn ring-request [raw]
+  {:uri (-uri raw)
+   :request-method (-request-method raw)
+   :path-params (-path-params raw)})
+
+(defn record-request [raw]
+  (->RecordRequest (-uri raw) (-request-method raw) (-path-params raw)))
+
+(defrecord RawRingRequest [raw]
+  RingRequest
+  (get-uri [_] (-uri raw))
+  (get-request-method [_] (-request-method raw))
+  (get-path-params [_] (-path-params raw)))
+
+(def raw
+  (reify
+    RawRequest
+    (-uri [_] "/ping")
+    (-request-method [_] :get)
+    (-path-params [_] {:a 1})))
+
+(defn bench-all! []
+
+  ;; 530ns
+  (title "potemkin zero-copy")
+  (assert (= :get (:request-method (->ZeroCopyRequest raw))))
+  (cc/quick-bench
+    (let [req (->ZeroCopyRequest raw)]
+      (dotimes [_ 10]
+        (:request-method req))))
+
+  ;; 73ns
+  (title "map copy-request")
+  (assert (= :get (:request-method (ring-request raw))))
+  (cc/quick-bench
+    (let [req (ring-request raw)]
+      (dotimes [_ 10]
+        (:request-method req))))
+
+  ;; 7ns
+  (title "record copy-request")
+  (assert (= :get (:request-method (record-request raw))))
+  (cc/quick-bench
+    (let [req (record-request raw)]
+      (dotimes [_ 10]
+        (:request-method req))))
+
+  ;; 7ns
+  (title "request protocols")
+  (assert (= :get (get-request-method (->RawRingRequest raw))))
+  (cc/quick-bench
+    (let [req (->RawRingRequest raw)]
+      (dotimes [_ 10]
+        (get-request-method req)))))
+
+(comment
+  (bench-all!))


Add test for deploy task.

Add test for deploy task.

error: pathspec 'test/test_deploy.clj' did not match any file(s) known to git

--- test/test_deploy.clj
+++ test/test_deploy.clj
@@ -0,0 +1,18 @@
+(ns test-deploy
+  (:use [leiningen.deploy] :reload)
+  (:use [clojure.test]
+        [clojure.java.io :only [file]]
+        [leiningen.core :only [read-project defproject]]
+        [leiningen.util.file]))
+
+(def test-project (read-project "test_projects/sample/project.clj"))
+
+(deftest test-deploy
+  (delete-file-recursively "/tmp/lein-repo" :silently)
+  (deploy test-project "file:///tmp/lein-repo")
+  (let [dir (file "/tmp/lein-repo/nomnomnom/nomnomnom/0.5.0-SNAPSHOT/")
+        files (.list dir)
+        year (+ 1900 (.getYear (java.util.Date.)))]
+    (is (seq files))
+    ;; TODO: this is vulnerable to the y3k bug!
+    (is (seq (filter #(re-find #"nomnomnom-0.5.0-2\d{7}\." %) files)))))


removing relativize code

removing relativize code

--- sidecar/src/figwheel_sidecar/core.clj
+++ sidecar/src/figwheel_sidecar/core.clj
@@ -12,9 +12,9 @@
    [clojure.edn :as edn]
    [clojure.java.io :refer [as-file] :as io]
    [digest]
-   [clojurescript-build.api :as bapi]
    [clj-stacktrace.core :refer [parse-exception]]
    [clj-stacktrace.repl :refer [pst-on]]
+   [clojurescript-build.api :as cbapi]
    [clojure.pprint :as p]))

 ;; get rid of fs dependancy
@@ -149,7 +149,6 @@
   .ie a file that starts with (ns example.path-finder) -> example.path_finder"
   [file-path]
   (try
-
     (when (.exists (as-file file-path))
       (with-open [rdr (io/reader file-path)]
         (-> (java.io.PushbackReader. rdr)
@@ -186,34 +185,10 @@
                  (:cljs changed-source-file-paths))))))

 (let [root (norm-path (.getCanonicalPath (io/file ".")))]
-  (defn relativize-resource-paths
+  (defn remove-root-path
     "relativize to the local root just in case we have an absolute path"
-    [{:keys [resource-paths]}]
-    (mapv #(string/replace-first (norm-path %)
-                                 (str (norm-path root)
-                                      "/") "") resource-paths)))
-
-(defn remove-resource-path [{:keys [http-server-root] :as state} path]
-  (let [path' (norm-path path)
-        rp (first (filter (fn [x] (.startsWith path' (str x "/" http-server-root)))
-                          (relativize-resource-paths state)))
-        to-remove (str rp "/" http-server-root)]
-    (string/replace path' to-remove "")))
-
-(defn ns-to-server-relative-path
-  "Given the state and a namespace makes a path relative to the server root.
-  This is a path that a client can request. A caveat is that only works on
-  compiled javascript namespaces."
-  [{:keys [output-dir] :as state} ns]
-  (let [path (.getPath (bapi/cljs-target-file-from-ns output-dir ns))
-        p    (remove-resource-path state path)]
-    (if (not= (first p) \/)
-      (str "/" p)
-      p)))
-
-(defn make-serve-from-display [{:keys [http-server-root] :as opts}]
-  (let [paths (relativize-resource-paths opts)]
-    (str "(" (string/join "|" paths) ")/" http-server-root)))
+    [path]
+    (string/replace-first (norm-path path) (str root "/") "")))

 (defn file-changed?
   "Standard md5 check to see if a file actually changed."
@@ -237,14 +212,14 @@
   (keep
    #(when (file-changed? st %)
       { :dependency-file true
-        :file (remove-resource-path st %) })
+        :file (remove-root-path %) })
    (dependency-files st)))

 (defn make-sendable-file
   "Formats a namespace into a map that is ready to be sent to the client."
   [st nm]
   (let [n (-> nm name underscore)]
-    { :file (ns-to-server-relative-path st n)
+    { :file (str (cbapi/cljs-target-file-from-ns (:output-dir st) nm))
       :namespace (cljs.compiler/munge n)
       :meta-data (meta nm) }))

@@ -308,7 +283,7 @@
       (map (fn [x] (.getPath x)) (updated?)))))

 (defn make-css-file [state path]
-  { :file (remove-resource-path state path)
+  { :file (remove-root-path path)
     :type :css } )

 (defn send-css-files [st files]
@@ -355,8 +330,13 @@
                                     open-file-command] :as opts}]
   ;; I'm spelling this all out as a reference
   { :unique-id (or unique-id (project-unique-id))
-
-    :resource-paths (or resource-paths ["resources"])
+
+    :resource-paths (or
+                     (and resource-paths
+                          (empty? resource-paths)
+                          ["resources"])
+                     resource-paths
+                     ["resources"])
     :css-dirs css-dirs
     :http-server-root (or http-server-root "public")
     :output-dir output-dir
@@ -387,10 +367,7 @@
   ([opts]
    (let [state (create-initial-state (resolve-ring-handler opts))]
      (println (str "Figwheel: Starting server at http://localhost:" (:server-port state)))
-     (println (str "Figwheel: Serving files from '"
-                   (make-serve-from-display state) "'"))
      (assoc state :http-server (server state)))))

 (defn stop-server [{:keys [http-server]}]
   (http-server))
-


Add cross experiment compare

Add cross experiment compare

error: pathspec 'Jobs/rnaseq-xcompare-job-template.clj' did not match any file(s) known to git

--- Jobs/rnaseq-xcompare-job-template.clj
+++ Jobs/rnaseq-xcompare-job-template.clj
@@ -0,0 +1,10 @@
+
+{:nodes
+ {:cmp
+  {:name "rnaseq-xcompare",
+   :type "tool",
+   :args []}
+  :prn1 {:type "func",
+         :name "prn"}},
+ :edges
+ {:ph2 [:prn1]}}


cross-project rates

cross-project rates

error: pathspec 'src/atom_finder/questions/cross_project_rates.clj' did not match any file(s) known to git

--- src/atom_finder/questions/cross_project_rates.clj
+++ src/atom_finder/questions/cross_project_rates.clj
@@ -0,0 +1,34 @@
+;; Do various projects have similar atom rates or
+;; do different projects promote different coding styles
+
+(ns atom-finder.questions.cross-project-rates
+  (:require
+   [atom-finder.atoms-in-dir :refer :all]
+   [atom-finder.classifier :refer :all]
+   [atom-finder.constants :refer :all]
+   [atom-finder.util :refer :all]
+   [clojure.pprint :refer :all]
+   [clojure.string :as string]
+   [swiss.arrows :refer :all]
+   [schema.core :as s]
+   ))
+
+
+'((->>
+ "atom-counts_2017-10-25_1.edn"
+ read-data
+ (drop 1)
+ (def atom-counts)))
+
+'((->>
+ atom-counts
+ (remove nil?)
+ (group-by #(->> % :file (re-find #"[^/]*")))
+ (map-values #(->> % (map :atom-counts) (reduce (partial merge-with +))))
+ (def atom-sums)))
+
+'((->>
+ atom-sums
+ (map (fn [[project counts]] (assoc counts :project project)))
+ (maps-to-csv "atom-counts.csv")
+ ))


Declare cthulhu symbol to be able to use it in a method prior to the game starting.

remote: Support for password authentication was removed on August 13, 2021.
remote: Please see https://docs.github.com/en/get-started/getting-started-with-git/about-remote-repositories#cloning-with-https-urls for information on currently recommended modes of authentication.
fatal: Authentication failed for 'https://github.com/Yoshiyuka/cthulhu.git/'


[DC] test cases with try/finally

[DC] test cases with try/finally

remote: Support for password authentication was removed on August 13, 2021.
remote: Please see https://docs.github.com/en/get-started/getting-started-with-git/about-remote-repositories#cloning-with-https-urls for information on currently recommended modes of authentication.
fatal: Authentication failed for 'https://github.com/democracyworks/election-notification-works.git/'


add contest dates

add contest dates

remote: Support for password authentication was removed on August 13, 2021.
remote: Please see https://docs.github.com/en/get-started/getting-started-with-git/about-remote-repositories#cloning-with-https-urls for information on currently recommended modes of authentication.
fatal: Authentication failed for 'https://github.com/clojurecup/cc2014-frontend.git/'


Prepare shredder

Prepare shredder

error: pathspec 'frontend/src/crunsher/shredder/main.cljs' did not match any file(s) known to git

--- frontend/src/crunsher/shredder/main.cljs
+++ frontend/src/crunsher/shredder/main.cljs
@@ -0,0 +1 @@
+(ns crunsher.shredder.main)


CMR-348: Added file to generate elastic docs from orbit calcualted spatial domains.

error: pathspec 'src/cmr/indexer/services/concepts/orbit_calculated_spatial_domain.clj' did not match any file(s) known to git

--- src/cmr/indexer/services/concepts/orbit_calculated_spatial_domain.clj
+++ src/cmr/indexer/services/concepts/orbit_calculated_spatial_domain.clj
@@ -0,0 +1,30 @@
+(ns cmr.indexer.services.concepts.orbit-calculated-spatial-domain
+  "Contains functions for converting orbit calcuated spatial domains into a elastic documents"
+  (:require [clojure.string :as s]
+            [cmr.common.services.errors :as errors]))
+
+(defn ocsd->elastic-doc
+  "Converts a OCSD into the portion going in an elastic document"
+  [ocsd]
+  (try
+  (let [{:keys [orbital-model-name
+                orbit-number
+                start-orbit-number
+                stop-orbit-number
+                equator-crossing-longitude
+                equator-crossing-date-time]} ocsd]
+    {:orbital-model-name orbital-model-name
+     :orbital-model-name.lowercase (when orbital-model-name (s/lower-case orbital-model-name))
+     :orbit-number orbit-number
+     :start-orbit-number start-orbit-number
+     :stop-orbit-number stop-orbit-number
+     :equator-crossing-longitude equator-crossing-date-time
+     :equator-crossing-date-time equator-crossing-date-time})
+  (catch Throwable e
+    (println e)
+    (.printStackTrace e))))
+
+(defn ocsds->elastic-docs
+  "Converts the ocsds into a list of elastic documents"
+  [granule]
+  (map ocsd->elastic-doc granule))


using fill-in-blanks style for everything

remote: Support for password authentication was removed on August 13, 2021.
remote: Please see https://docs.github.com/en/get-started/getting-started-with-git/about-remote-repositories#cloning-with-https-urls for information on currently recommended modes of authentication.
fatal: Authentication failed for 'https://github.com/croeder/clojure-koans-work.git/'


Added logging to debug heroku issue

Added logging to debug heroku issue

remote: Support for password authentication was removed on August 13, 2021.
remote: Please see https://docs.github.com/en/get-started/getting-started-with-git/about-remote-repositories#cloning-with-https-urls for information on currently recommended modes of authentication.
fatal: Authentication failed for 'https://github.com/amedw/mud-server.git/'


Added othello solution

Added othello solution

error: pathspec 'src/main/cljc/clojure_club/x124_analyze_reversi/brockturner.cljc' did not match any file(s) known to git

--- src/main/cljc/clojure_club/x124_analyze_reversi/brockturner.cljc
+++ src/main/cljc/clojure_club/x124_analyze_reversi/brockturner.cljc
@@ -0,0 +1,24 @@
+(ns clojure-club.x124-analyze-reversi.brockturner)
+
+(defn gen-path [board path-type end-type start-y-x dir-y-x]
+  (when-not (apply = 0 dir-y-x)
+    (loop [path [start-y-x]]
+      (let [prev (map + dir-y-x (last path))
+            next (get-in board prev)]
+        (cond
+          (= path-type next) (recur (conj path prev))
+          (= end-type next) path
+          :else nil)))))
+
+(defn get-moves [board turn]
+  (->> (for [y (-> board count range)
+             x (-> y board count range)
+             :when (= 'e (get-in board [y x]))]
+         (for [x-dir (range -1 2)
+               y-dir (range -1 2)]
+           (gen-path board ({'w 'b 'b 'w} turn) turn [y x] [y-dir x-dir])))
+       (apply concat)
+       (filter #(-> % seq count (> 1)))
+       (reduce (fn [m [start & path]]
+                 (assoc m start (apply hash-set path)))
+               {})))


ui components for forms, text input, dropdown. textarea, checkbox, and radio

remote: Support for password authentication was removed on August 13, 2021.
remote: Please see https://docs.github.com/en/get-started/getting-started-with-git/about-remote-repositories#cloning-with-https-urls for information on currently recommended modes of authentication.
fatal: Authentication failed for 'https://github.com/starcity-properties/odin.git/'


Updating some of the failure reasons.

Updating some of the failure reasons.

remote: Support for password authentication was removed on August 13, 2021.
remote: Please see https://docs.github.com/en/get-started/getting-started-with-git/about-remote-repositories#cloning-with-https-urls for information on currently recommended modes of authentication.
fatal: Authentication failed for 'https://github.com/shaunstanislaus/cljs2go.git/'


add simple REPL script

add simple REPL script

error: pathspec 'script/repl.clj' did not match any file(s) known to git

--- script/repl.clj
+++ script/repl.clj
@@ -0,0 +1,3 @@
+(require '[cljs.repl :as repl])
+(require '[cljs.repl.node :as node])
+(repl/repl (node/repl-env))


More simplification, no need to build cljs.core every time


always use a new MIDI channel for each instrument

Initially I was trying to save channels (since there are only 16) by doubling up on channels when there are two instances of the same MIDI instrument.

However, while transcribing the prelude to Bach's first cello suite I ended up needing to create a second cello instance (which was made to share a MIDI channel with the first one) for the overlapping 'A' pedal tone notes alternating between the open A string and unison 'A' note on the D string, and I discovered that the MIDI note-off events for that 'A' were clobbering those of the other part.

Having two instances of an instrument share a MIDI channel is clearly asking for trouble. From now on, one MIDI instrument (instance) = one MIDI channel.

remote: Support for password authentication was removed on August 13, 2021.
remote: Please see https://docs.github.com/en/get-started/getting-started-with-git/about-remote-repositories#cloning-with-https-urls for information on currently recommended modes of authentication.
fatal: Authentication failed for 'https://github.com/jtbeckha/alda.git/'


stuff for newer version of cider.

stuff for newer version of cider.

remote: Support for password authentication was removed on August 13, 2021.
remote: Please see https://docs.github.com/en/get-started/getting-started-with-git/about-remote-repositories#cloning-with-https-urls for information on currently recommended modes of authentication.
fatal: Authentication failed for 'https://github.com/sw1nn/dotfiles.git/'