Hacky, but working:

(require '[selmer.filters :as f])
(require '[selmer.parser :as p])
(f/add-filter! :get (fn [m k] (get m (keyword k))))
(s/render "[{{ x|get:@k }}]" {:k "y", :x {:y "foo"}})
=> "[foo]"

Maybe do the filtering before rendering in selmer

Yeah, I ended up restructuring it by making status a map with :selected? key populated on the backend.

Doesn't read do that for you?

sorry, I meant after read-string

should I set the *file* binding during read-string?

I think you could do that

Without looking at code, I don't remember all the env that affects this

I've looked through it a bit but not too fluent in reading through the java stuff. Well thank you, imagine you're pretty busy with the conference. Trying to improve the error messages in Clerk before the workshop 🙃

;; An ugly hack. Not sure setting the column number is very useful, anyway.
(defn set-column!
  [^clojure.lang.LineNumberingPushbackReader reader column]
  (when-let [^java.lang.reflect.Field field (.getDeclaredField clojure.lang.LineNumberingPushbackReader "_columnNumber")]
    (-> field (doto (.setAccessible true)) (.set reader column))))

(def reader
  (clojure.lang.LineNumberingPushbackReader. (java.io.StringReader. "(throw (ex-info \"Boom!\" {:a 1}))")))

(set-column! reader (int 42))
(.setLineNumber reader (int 84))

(binding [*file* "/path/to/my.clj"
          *source-path* "my.clj"
          *ns* (the-ns 'user)]
  (eval (read reader)))

(-> *e Throwable->map clojure.main/ex-triage clojure.main/ex-str)
;;=> "Execution error (ExceptionInfo) at user/eval28938 (my.clj:84).\nBoom!\n"

Alternatively, you can use the eval-file metadata:

Clojure 1.11.1
user=> ^{:clojure.core/eval-file "foo.clj" :line 84} (/ 1 0)
Execution error (ArithmeticException) at user/eval1 (foo.clj:84).
Divide by zero
user=>

But only if you’re evaluating something you can attach metadata to.

user=> (eval (read-string "^{:clojure.core/eval-file \"foo.clj\" :line 84} (/ 1 0)"))
Execution error (ArithmeticException) at user/eval8 (foo.clj:84).
Divide by zero

@U5H74UNSF Have you considered using clojure.core/eval-file ?

user=> (eval (with-meta '(/ 1 0) {:clojure.core/eval-file "foo.clj"}))
Execution error (ArithmeticException) at user/eval20 (foo.clj:1).
Divide by zero

lol, @U4ZDX466T just mentioned it

@U4ZDX466T @U04V15CAJ thank you, haven't considered it as I just learned about it from you, just what I needed thanks!

(try
  (eval (with-meta '(/ 1 0) {:line 99 :col 0 :clojure.core/eval-file "/User/mk/foo.clj"}))
  (catch Throwable t
    (clojure.main/ex-triage (Throwable->map t))))

Seems like a good overview of graph libraries here: https://github.com/simongray/clojure-graph-resources

Alternative in what way? That library is explicitly for modeling the dag of clojure namespaces, where the compiler explicitly throws a fit if you have cycles

@UE72GJS7J Thanks! Most linkx are probably way overkill but maybe I'll find what I need @U0NCTKEV8 Well you can use it for any use case that involves a simple dependency scheme. The only trouble is that it throws on circular dependencies because that is indeed not its purpose.

right, so what features are you actually looking for in an alternative, since you aren't using the library you are asking for alternatives to for its main use case

Ideally, the same kind of API but simply allowing circular deps. Being able to declare a direct dependency between X nodes and then computing transitive deps for any node.

Really just that 😅

That's a graph with directed edges. I don't think you'll find a library with the same API as Stuart's because it's implementing a DAG with the specific purpose of mirroring Clojure namespace dependency graphs. But there are lots of good libraries that will do what you want if you figure out the more general graph terminology

:jvm/base is not a recognized key in deps.edn. You need to put them in an alias {:aliases {:jvm/base {:jvm-opts […]}}} and then use the alias

the -J prefix is only for the command line, you should not use it in an alias :jvm-opts

{:paths ["src"]
 :deps {ring/ring {:mvn/version "1.9.5"}
        datalevin/datalevin {:mvn/version "0.6.17"}
        rum/rum   {:mvn/version "0.12.9" :exclusions
                   [cljsjs/react cljsjs/react-dom]}}
 :aliases {:jvm-base
           {:jvm-opts ["--add-opens=java.base/java.nio=ALL-UNNAMED"
                       "--add-opens=java.base/sun.nio.ch=ALL-UNNAMED"]}}}

Thanks, are the jvm-opts persisted across restarts, or should I run clj -A:jvm-base each time I start the app?

jvm options are options passed to the jvm on startup. They are not persisted across restarts

(if-let [[k v] (some #(find m %) [:key1 :key2 :key3])]
  …))

I usually use find if I want to have both the key and the value, or if I want to have a result, even if the value is nil or false

when you want to tell the difference between a key that is associated with nil and a key that is not present

@U01KZDMJ411 although (get m k ::some-obscure-default) is more explicit about distinguishing between absence and nil-valued

that doesn't play nice with conditionals, ::some-obscure-default value will always be true even if the key is absent

Isn't contains? better for testing key presence, regardless of (falsy) value?

yes but if you need to the test and get the value you have to do two map lookups