I’m trying to convert to deps.edn from a lein project. So far I have most things working except java compilation for tests. Any test that includes a java file or references one fails with filenotfound (not on classpath). How do I tell deps.edn test runner to run a compile command and then use the java+clj classpath / output for tests? deps.edn:

:paths   ["src" "java"]
:deps    {org.clojure/clojure {:mvn/version "1.10.3"}}
:test  {:extra-paths ["test"]
                   :extra-deps  {io.github.cognitect-labs/test-runner
                                 {:git/tag "v0.5.0" :git/sha "b3fd0d2"}}
                   :main-opts   ["-m" "cognitect.test-runner"]
                   :exec-fn     cognitect.test-runner.api/test}

You'll have a build.clj thing that calls javac and writes class files to disk somewhere (prior to uber jarring) you need to call that before running your tests and add the output directory to paths when running your tests

You'll likely want to write a build.clj function that bundles that up

Like pass a command into :main-opts or something ?

I have a function that just compiles java to target as a separate step much like the example on http://clojure.org deps page

Sure yeah, that

It writes the classfiles to disk somewhere

So to run your tests you call that first, then have some alias which adds the classfiles output directory to your paths, and use that alias for running tests

Can an alias call an alias so I can put it in a single clj command, or are you suggesting a bash script or something that runs multiple commands? I can try the latter, straightforward enough. thanks!

No, you shell out, start a new jvm running your tests

https://github.com/seancorfield/build-clj/blob/main/src/org/corfield/build.clj

Has a function for that

You can also search for test in #tools-build

cool, thanks!

Dear friends, I am once again having an inner struggle about licenses. With respect to Clojure, there is this [interesting article from Juxt](https://www.juxt.pro/blog/prefer-mit), but there does not seem to be a lot more intel available. I'd be grateful if you could share more resources like that, should they exist. Personally, I've always been drawn to copyleft-ish licenses. While full GPL is always controversial, there are more sensible options. Notably, MPL 2.0 have often seemed quite reasonable to me, although my legal expertise is noob-worthy. Hence, for your professional endaveours, related to the usage of Clojure in any nature, what is your stance on MPL 2.0 or other similar copyleft-ish licenses? Is is a no-go like GPL often is for a lot of companies? If so, is it a preventive measure or are you aware of obvious compatibility issues, especially with respect to the overall Clojure ecosystem?

I'm using Selmer to template out some plain text reports. One unfortunate thing is that the lines that contain only Selmer tags (e.g., {% for thing in things %} end up in the rendered output as blank lines. I realize for HTML this doesn't matter, but for plain text it does indeed. Does anyone know of a workaround for this, or perhaps another similar library without this limitation?

I am developing a game in clojure and the entities are stored in atom’s. Each entity holds a map as value when deref’ed. Now entities are referred to as ‘entity’ in function arguments and local variables. Some functions like ‘get-position’ are looking up values in the nested entity-hashmap. Now the question is how to name the entity when dereferenced in the function args / local variables? -> Maybe entity-hash, entity-value, entityv, entityval … Is there anyone who was experienced this issue?

Also I am not sure where to call deref on an entity. For example I have a function

(defn get-position [entity] (:value (:position @entity)))

(defn get-position [entity-hash] (:value (:position entity-hash)))

I'm not sure I understand the name issue, but for your second question, you should 100% pass the already deref'd value. There should only be a few places where you need to deref your atom, not far from 1. I think seeing more of the code would be helpful

The name issue is - some functions work on the atom (checking something, swap!-ing something ,… ) and some functions work on the internal map data structure. - and I have to find two different names.

I also agree that get-position for example should just work on plain map data structure, it makes it much simpler and straightforward.

I think I am going for ‘entity’ and ‘entitv’.

It is far better to make as many pure functions as you can - they are easier to write, easier to test, and composable. I generally try to avoid making a function that manipulates the atom at all and favor writing that inline at the place of use, using swap! to apply a pure function there, thus keeping all stateful ops as close to the state as possible

Thank you Alex. But what do you think about the naming?

@mx2000 I would recommend privileging the immutable version, keeping those called entity and not derefing inside your functions, but calling the ATOM something special, like !entity (I forget where I first saw the exclamation point form). Then push calls like (get-position @!entity) up as high as possible in your stack.

Then you can test almost everything as @alexmiller says without any atoms at all, but with maps you build in your tests. here is an immutable blackjack game I built long ago… https://github.com/sritchie/blackjack/blob/develop/src/blackjack/core.clj I think I actually avoided ANY state by cheating and calling prompt inside one of the functions (https://github.com/sritchie/blackjack/blob/develop/src/blackjack/core.clj#L377-L393), then pushing everything for the full game-loop into a loop-recur. But I was proud at the time that all functions except for the one with prompt operated on immutable maps. much easier to test: https://github.com/sritchie/blackjack/blob/develop/test/blackjack/core_test.clj

If you avoid passing atoms into functions at all, there's nothing to name :)