Clojurians Log v2

I am trying to list all files in a configs resources directory, read them as yaml, and merge it all in a config map during dev with CIDER, this works fine:

(def config (->> (io/resource "configs")
                 (io/file)
                 (.listFiles)
                 (map yaml/from-file)
                 (reduce merge)))

Caused by: java.lang.IllegalArgumentException: Not a file: jar:file:/path/to/app.jar!/configs

ok I solved it using:

(def project-path (.getParent
                   (io/file (.getCanonicalPath
                             (io/file "project.clj")))))

(def config (->> (str u/project-path "/resources/configs")
                 (io/file)
                 (.listFiles)
                 (map yaml/from-file)
                 (reduce merge)))

My guess is because io/resources and io/file look in different places. io/file is from the root of the project or an absolute path. io/resources is relative to the project/resources directory.

I've got a question on something I saw recently in one of the explanations of https://findka.com/blog/essays-implementation/

(defn send** [api-key opts]
  (http/post (str "<https://api.mailgun.net/v3/mail.findka.com/messages>")
    {:basic-auth ["api" api-key]
     :form-params opts}))

(defn send* [{:keys [mailgun/api-key template data] :as opts}]
  (if (some? template)
    (let [template-fn (get templates template)
          mailgun-opts (template-fn data)]
      (send** api-key mailgun-opts))
    (send** api-key (select-keys opts [:to :subject :text :html]))))

(defn send [{:keys [params template recaptcha/secret-key] :as sys}]
  (if (= template :biff.auth/signup)
    (let [{:keys [success score]}
          (:body
            (http/post "<https://www.google.com/recaptcha/api/siteverify>"
              {:form-params {:secret secret-key
                             :response (:g-recaptcha-response params)}
               :as :json}))]
      (when (and success (&lt;= 0.5 score))
        (send* sys)))
    (send* sys)))

Is there anything special going on with the * in those function names?

nothing built into clojure. I've also never seen that convention before. not sure if that's just a convention by the author or if there some's tooling used by the author that relies on it.

interesting, https://grep.app/search?current=3&q=defn%5B%20%5D%5Ba-z-%5D%2B%5B%2A%5D&regexp=true&filter[lang][0]=Clojure seems to be used for naming helper functions

Feels like it would be a good addition to this section of the FAQ https://clojure.org/guides/faq#qmark_bang

The convention is typically that foo* is usually some sort of implementation piece of foo itself.

For example, you might have a function fetch-data that caches results for a short time, and it might call fetch-data* which would fetch the data but not cache it.

Does that help @btenggren20?

Yes! Thanks a bunch. I read it as breaking out peices of send which are sent explicitly but the rubyist in me saw them as splat operators and I was curious to know if there was any magic in them

You'll also see *foo* which is a convention for dynamic Vars that can be used with binding.

I believe what you've written will fetch files "next to the jar". To load from the jar, try io/resource

And a little bit more than merely a convention, since the Clojure compiler warns if you name a Var with "earmuffs", but do not also declare it as ^:dynamic

Does it? I thought it used to, but you don't get a warning here:

user=> (def ^:dynamic foo 42)
#'user/foo
user=> (binding [foo 13] (println foo))
13
nil
user=> foo
42
user=>

user=> (def *foo* 42)
Warning: *foo* not declared dynamic and thus is not dynamically rebindable, but its name suggests otherwise. Please either indicate ^:dynamic *foo* or change the name.

Ah, yes, it's the other way around from what I was thinking.

So you can declare anything ^:dynamic but if you use earmuffs, you should use ^:dynamic.

I did, but io/resource does not work with directories when running with an uberjar, I mean I did not find out how to use it properly