Clojure Q&A - Recent questions in Tools

does deps.edd support "exclusion" with wild cards ?

Sat, 07 Feb 2026 21:12:28 +0000

maven supports this:

<dependency>
      <groupId>org.apache.hadoop</groupId>
      <artifactId>hadoop-common</artifactId>
      <version>${hadoop.version}</version>
      <exclusions>
        <exclusion>
          <groupId>*</groupId>
          <artifactId>*</artifactId>
        </exclusion>
      </exclusions>

while Clojure does not , it seems

Improving curl options for CLI install scripts (brew-install)

Mon, 26 Jan 2026 12:39:44 +0000

Hi!

I'm the maintainer for Heroku's Clojure buildpack. It uses the install scripts from clojure/brew-install to install the CLI. I noticed intermittent install failures related to the download of the Clojure tools. I believe most of them could be avoided with a slightly changed curl command line options.

I opened a PR before realizing that PRs will not be accepted, so I'm starting this thread to properly get the discussion going. For reference, the closed PR can be found here: https://github.com/clojure/brew-install/pull/10

I believe these options would improve the download behaviour for all users, but especially when used in automations:

--connect-timeout 3 (https://curl.se/docs/manpage.html#--connect-timeout)
Prevents hanging when server is unreachable.

--fail (https://curl.se/docs/manpage.html#-f)
Exit with error code 22 for HTTP responses with status codes >= 400.

--max-time 60 (https://curl.se/docs/manpage.html#-m)
Maximum time in seconds for the entire transfer operation. Prevents hanging indefinitely with slow connections.

--no-progress-meter (https://curl.se/docs/manpage.html#--no-progress-meter)
Introduced in curl 7.67.0 (Nov 2019). Disables the progress bar for cleaner output. But less drastic than --silent and will still output diagnostic information (i.e. retries).

--retry-max-time 60 (https://curl.se/docs/manpage.html#--retry-max-time)
Retry only within this time period (60 seconds). After this time expires, no more retries will be attempted.

--retry 5 (https://curl.se/docs/manpage.html#--retry)
Introduced in curl 7.12.3 (Dec 2004). Retry up to 5 times on transient errors (timeouts, HTTP 408, 429, 500, 502, 503, 504, 522, 524).

--retry-connrefused (https://curl.se/docs/manpage.html#--retry-connrefused)
Introduced in curl 7.52.0 (Dec 2016). Consider connection refused as a transient error for --retry.

These are obviously opinionated and my ask is not for these options specifically. Happy to get anything that will improve the situation. :)

Manuel

Prepping - cache invalidation

Tue, 16 Sep 2025 10:31:56 +0000

Following the existing example:

https://clojure.org/reference/clojure_cli#deps_prep

{:paths ["src" "target/classes"]
 :deps/prep-lib
 {:ensure "target/classes"
  :alias :build
  :fn compile-java}}

How does one control cache invalidation? i.e. if any .java file has been added or modified, a compilation should be re-triggered.

The linked doc says:

:ensure - directory existence determines whether prep is needed

It seems to me that only the existence of a directory may not be sufficient to determine if a lib is 'prepped?' One might want to add a custom function, for instance.

This use case is particularly painful in monorepos, where a given sub-project may depend on a sibling project's java classes.

There's the option of wrapping things with babashka, which worked well for me, however it is surprising that standalone tools.deps appeared to be insufficient for this use case.

how do you set -Djdk.attach.allowAttachSelf enabled so that I can interrupt a cider repl in emacs

Tue, 02 Sep 2025 15:56:27 +0000

In a long running process I want to interrupt the repl.
if you set deps.edn with the following:

:aliases {:dev {:jvm-opts ["-Djdk.attach.allowAttachSelf enabled"
                            "-XX:+PreserveFramePointer"
                            "-XX:+UnlockDiagnosticVMOptions"
                            "-XX:+DebugNonSafepoints"]}}

and then in init.el:

(setq cider-clojure-cli-global-options "-Adev")

you can avoid the following error:

ERROR: Cannot stop thread on JDK21+ without -Djdk.attach.allowAttachSelf 
enabled, see https://nrepl.org/nrepl/installation.html#jvmti.

but the java process still continues

tools.deps.cli.api/mvn-install docstring typo

Sat, 09 Aug 2025 15:57:48 +0000

> clojure -X:deps help/doc :fn mvn-install
-------------------------
clojure.tools.deps.cli.api/mvn-install
([{:keys [jar pom lib version classifier local-repo]}])
  Install a jar and pom to the Maven local cache.
  The pom file must either be supplied, or generated based
  on provided lib/version/classifier, or provided inside the jar.
  The group/artifact/version coordinate will be pulled from the
  pom source as above.

  Required:
    :jar (reqired) - path to jar file (embedded pom used by default)

Should be :jar (required).

In addition, further on in the docstring:

  Execute ad-hoc:
    clj -X:deps mvn/install :jar '"foo-1.2.3.jar"'

That should be mvn-install, not mvn/install.

clojure -X:deps find-versions doesn't sort tags correctly?

Sat, 09 Aug 2025 14:04:34 +0000

When Maven versions include pre-releases, find-versions seems to sort correctly:

> clojure -X:deps find-versions :lib hiccup/hiccup
Downloading: hiccup/hiccup/maven-metadata.xml from clojars
{:mvn/version "2.0.0-alpha1"}
{:mvn/version "2.0.0-alpha2"}
{:mvn/version "2.0.0-RC1"}
{:mvn/version "2.0.0-RC2"}
{:mvn/version "2.0.0-RC3"}
{:mvn/version "2.0.0-RC4"}
{:mvn/version "2.0.0-RC5"}
{:mvn/version "2.0.0"}

However, when a library is git-only with tags and pre-releases exist, they seem to be alpha-sorted instead:

> clojure -X:deps find-versions :lib io.github.seancorfield/deps-new
{:git/tag "v0.7.1-rc", :git/sha "5a6168d"}
{:git/tag "v0.8.0", :git/sha "2f96530"}
{:git/tag "v0.8.1", :git/sha "2859baf"}
{:git/tag "v0.9.0", :git/sha "da2f764"}
{:git/tag "v0.9.0-rc", :git/sha "b32e0f2"}
{:git/tag "v0.10.0", :git/sha "20e82f8"}
{:git/tag "v0.10.1", :git/sha "a90029c"}
{:git/tag "v0.10.1-rc", :git/sha "35159b5"}

Those -rc versions should sort before the full release.

POSIX-style command line arguments in tools (-T)

Thu, 03 Jul 2025 21:06:46 +0000

I have a couple command line tools written as libraries that I'd like to expose as proper Clojure Tools. They have classic POSIX-style command line interfaces, relying on tools.cli. I could add an -X kv-map interface, but there are a number of boolean flags that would not translate well to :foo true style (such as arbitrary file paths).

Is there a way to pass arbitrary arguments to a clojure Tool without using the kv-map style?

And if not, would there be interest in a flag or option that would allow for such a thing?

Improve clojure cli error msg: "The following libs must be prepared" could include "clojure -X:deps prep"

Sun, 08 Jun 2025 17:57:20 +0000

This happens basically every time I add a dependency that needs prepping. I see the error, but don't have the prep command memorized so I have to look it up. It would be very helpful if the error printed also included the command invocation for prepping, clojure -X:deps prep.

How to uberjar without bundling source code?

Sat, 29 Mar 2025 19:58:38 +0000

The example given in https://clojure.org/guides/tools_build#_compiled_uberjar_application_build also copies all source files from the src folder into the uberjar. As I understand it, this is not strictly required for a compiled application? In my scenario where I don't want to distribute my source code along with the uberjar, can I simply not copy or exclude clojure source code? Or does that have subtle side effects? Why would I want source code in my uberjar to begin with?

a) how: programmatically set REPL ‘context’ ‘prj-1 aware’? b) how: programmatically switch REPL ‘context’ ‘prj-n aware’?

Sun, 23 Feb 2025 16:56:50 +0000

Ok, regardless of editor, running clj in a directory will start a repl that has "project context" to project deps.edn in that directory, and that is the way that most Clojure developers create a connected repl.

The implication seems to be to work on a different project one must (System/exit 0) VM and start another VM using clj command to ‘create a connected repl’ to project deps.edn in a different directory? This appears to be idiomatically (colloquially) referred to as ‘restarting the REPL’ I believe?

Seems rather draconian for a dev env, let alone a lisp dev env? I thought the highly dynamic heritage of lisp replete with multiple REPLs was universally sought after? 10 years later and no multiple REPLs for clojure? Personally, I’m somewhat surprised, but maybe nobody really wants, needs or requires multiple clojure REPLs? I think multiple REPLs could be transformational in many use cases IMHO, or maybe I’m really ‘out of the loop’ no pun intended?

03-10-2015 Clojure stream socket repl discussion (https://groups.google.com/g/clojure-dev/c/Dl3Stw5iRVA/m/mgwvmEnjnBoJ) several notable sub-quotes:

“I think it is important, with tooling, to have the broadest, open notion of the types of 'use cases' for Clojure, and for workflows of people using Clojure, lest you actually limit them. I hope people are able to write their languages and DSLs, test embedded control/debug consoles, design next-generation REPLs and debuggers, grab data dumps etc, all from their REPL. That's the heritage of Lisp. Many people are doing data science, languages, genetics, rule-systems etc type things with Clojure, not just web apps

But it is quite common in rich Common Lisp IDEs like Lispworks for people to have multiple listener (REPL) sessions open at the same time (against the same runtime). You can launch long running processes that produce streaming output, switch to another listener and continue interaction and development, have separate listeners for separate contexts/state/command-history etc. There's a lot to Lisp development that's not RPC.

Note multiple listeners, data inspectors and more. Maybe not the latest GUIs, but the capabilities should be a source of inspiration for any Clojure IDE.”

Previously hinted personal end goal: exploit ‘critical mass’ for a (truly) ‘dynamic’ clojure dev env, including dynamic java recompilation, namespace reloading, etc. and include at a minimum:

clojure.repl.deps
clojure.tools.build.api (clojure.tools.build)
clojure.tools.deps
clojure.tools.deps.cli.api (clojure.deps.cli)
clojure.tools.namespace
clojure.tools.tools.api (clojure.tools.tools)
GitHub - clj-commons/virgil: Recompile Java code without restarting
the REPL (https://github.com/clj-commons/virgil)
other polyglot ‘evaluation/compilation’ TBD

I also included a few tools to help come back up to speed quicker:

GitHub - nubank/morse: A graphical, interactive tool for browsing
Clojure data (https://github.com/nubank/morse)
[clj-ns-browser/clj-ns-browser "2.0.0-SNAPSHOT"] – Clojars
(https://clojars.org/clj-ns-browser/versions/2.0.0-SNAPSHOT)

Eventually will look at many ‘current projects’ including: GitHub - HumbleUI/HumbleUI: Clojure Desktop UI framework (https://github.com/HumbleUI/HumbleUI) as stated to build better apps than possible with web, AND access full power of your computer (multithreaded), wouldn’t that be convenient?

Another quote from 03-10-2015 Clojure stream socket repl discussion (https://groups.google.com/g/clojure-dev/c/Dl3Stw5iRVA/m/IHoVWiJz5UIJ):

“REPL stands for something - Read, Eval, Print, Loop. It does not stand for - Eval RPC Server/Window.”

Anyway, that would be ERSW, seriously, I couldn’t agree more, a required lisp feature, for me anyway: multiple simultaneous-concurrent (multi-threaded) REPLs, I refer to as ‘Clojure Listeners’ (‘in-process’ or ‘against the same runtime’) non-socket non-nREPL non-LSP non-network non-middleware non-multi-VM based REPL approaches that support multiple simultaneous dev management ‘native VM’ approaches for polyglot projects ala GraalVM.

[SEE Multiple Clojure Listeners] (https://github.com/mgrisius/clj-mode/blob/0.9/Clojure_Listener_2025-02-23_09-02-41.jpg)

Note JavaScript Listener “JS-1” pictured. Could have python, R, ruby, or whatever language(s) available in GraalVM. ‘Clojure Listeners’ used with or without emacs, ‘regardless of editor’, in any Java VM for that matter. Could easily have multi-threaded socket-based listeners . . .

Clojure Listeners: multi-threaded, full history, type ahead, line editing, completion, pop-up menus, colorized output, colorized-balanced-brackets-([{, etc. Also working on other listener features: multi-line editing, enhanced source lookup, doc lookup, repo-artifact search, embeddable .e.g. in morse, etc. all leveraging the ‘purest clojure value chain possible’!

As previously mentioned, my basic ‘old style’ simple.bat with (~60mb) über jar simple compatibility with emacs lisp-inferior-mode works good with ‘legacy’ approach and new ‘CLI deps.edn approach’ basic use so far, both with ~1 second startup time. Zero optimization has been done thus far, e.g. GraalVM native image, etc.

My forward-looking goal & reason for asking initial question: compatibility with future clojure tool direction(s), NOT invent the next ‘technical debt’ ad hoc one-off hack. My Holy Graal: I want a fully dynamic long running VM under full clojure programmatic control.

So, the question remains: a) how to programmatically set REPL with ‘context’ for ‘project-1 aware’? b) how to programmatically switch REPL ‘context’ to ‘project-n aware’?

deps.edn support for :git/branch + :git/sha

Thu, 20 Feb 2025 06:04:47 +0000

Are there plans to add a :git/branch key for Git libs in deps.edn that works like :git/tag? In other words, Git refs (:git/branch or :git/tag) have to be paired with a Git SHA (:git/sha) to lock to a specific commit as Git refs can be updated to point to different commits.

For example:

{:deps {owner/repo {:git/url "https://github.com/owner/repo.git"
                    :git/branch "1.x"
                    :git/sha "2fd4e1c67a2d28fced849ee1bb76e7391b93eb12"}}}

The purpose is to support projects using major version branch workflows as compared to tag + release workflows.

Major version branch workflows may be used for things like private polyrepo projects (e.g. a web service where the API specs/model, backend, and infrastructure-as-code templates are split) that don't need the additional overhead that comes with using tags + releases.

Auto-update tools like Renovate or Dependabot can use the Git ref key in a deps.edn Git lib to update its locked :git/sha.

For tag + release workflows, this may be some heuristic like semantic versioning.

For major version branch workflows, the auto-update tool needs to use something like :git/branch to:

Tie break between a given Git SHA's descendants if there's multiple.
Ignore PR branches on the tip of a given branch (e.g. ignore a PR branch that's a descendant of the tip of the main branch).

a) how to start REPL with ‘context’ for ‘project-1 aware’? b) How to switch REPL ‘context’ to ‘project-n aware’?

Mon, 17 Feb 2025 17:14:46 +0000

Been away from clojure for a while, taking a fresh look at CLI & deps tool chain current status, direction & potential work flow(s). Previously maintained linux, macOS & MS Win / WSL2 dev envs, only looking at MS Win clojure right now.

Dev env includes GraalVM JDK 23, clojure 1.12.0, emacs 27.1 with minimal (ancient) lisp-inferior-mode clj-mode (https://github.com/mgrisius/clj-mode), and Apache ant/ivy 1.10.3 for Transitive Dependency Management (TDM), classpath & java command construction. My ‘legacy’ emacs, clojure & java code are operational again.

Using basic ‘old style’ simple.bat with (~60mb) über jar simple compatibility with emacs lisp-inferior-mode with ~1 second startup time, e.g. m-x eval-expression (run-lisp “simple.bat”):
java -cp E:\dev\projects\simple\target\0.0.1.standalone.jar clojure.main

Current goals include: convert to CLI & deps tools, among others.

Installed clj-msi (Clojure 1.12.0.1501) Clojure for Windows 25.5.3460.1501, create basic project, deps.edn etc. Can use CLI from cmd.exe or powershell.exe to execute basic actions: invoke REPL, check versions, download deps, create über jar etc. Command line stuff works good!

Not sure how best to leverage CLI & deps from a basic .bat file so that the resulting REPL is ‘project aware’, e.g. sees project deps.edn, build.clj, user.clj plus ‘tools.build’ related capabilities? So far, subtle differences between CLI interactive and basic .bat cmd.exe or powershell.exe results.

As the tools.build Guide states: “We want to write this program with our favorite programming language, Clojure, and tools.build is a library of functions commonly needed for builds that can be connected together in flexible ways. Writing a build program does take a bit more code than other declarative approaches, but can be easily extended or customized far into the future, creating a build that grows with your project.”

I prefer writing clojure code over complex cross platform compatible (shell) scripts, workarounds or hacks. So, I think I want full CLI functionality to use from the REPL to avoid incidental complexity, e.g. ‘very complicated’ problems discussed in Clojure CLI Reference in ‘Quoting keys and values’ related to platform specific issues wrt cmd.exe or powershell.exe concerns. Overall goal: avoid ‘technical debt’ from ANY platform specific minutiae for ANY shell, e.g. bash/tcsh, cmd.exe, powershell.exe, or even any new emacs lisp to focus solely on investment in purest clojure value chain possible.

BTW: happily seems like there’s ‘critical mass’ for a (fairly complete) ‘dynamic’ clojure dev env with tools akin to early lisp machine (lispm) (e.g. Symbolics) ‘procedural’ style defsystem.

Re-read clojure doc a few times, no mention on how a REPL is or s/b connected (‘in-process’) in a single VM with access to a ‘project’ with ‘tools.build’ and related features enabled? Or how to switch ‘build context’ to another ‘project’. Looked at monorepo / Polylith type subprojects that use ‘with-project-root’. Might be a good fit for a ‘mega project’ but doesn’t seem like a good fit (at least to me) for disparate, scattered or loosely coupled projects. Could keep a list of target project dirs and ‘map’ specific build tool process using ‘with-project-root’?

Also mentioned in tools.build Guide: ‘Parametrized builds’ that s/b easy to use from CLI and via programmatic use to generate :dev :test :debug :deploy :install :prod :maintenance or :whatever actions or artifacts are required in conjunction with a ‘clj -T:build action-name’ approach. Seems very reasonable, if there was a repeatable initial setup or process to make project deps.edn etc. & tools.build aware at a REPL.

To summarize, it would be nice to have a minimal .bat file and/or ‘user.clj’ to enable the CLI deps experience/capabilities/tools programmatically via REPL. Am I over thinking or missing anything here? Perhaps by design or maybe it’s too early to ask for normative, idiomatic or canonical recommendations?

My initial question is a) how to start a REPL with ‘context’ that is ‘project-1 aware’? b) How to switch a REPL ‘context’ to be ‘project-n aware’?

I apologize I’m just starting out with CLI, deps.edn, tools.build, user.clj, etc. and have not absorbed many of the intricacies re required libraries, operational details, setup and intended use cases. Any suggestions would be greatly appreciated, thanks for sharing any insights!

Confusing error message on deps.edn wrong git/url dependency

Thu, 05 Dec 2024 10:17:00 +0000

When you misspell the :git/url of a git dependency (or the dep name used to infer a url) the error says :

Cloning: https://github.com/MISSPELLED-ORG-OR-REPO-PATH
Error building classpath. Unable to clone /home/user/.gitlibs/_repos/https/github.com/MISSPELLED-ORG-OR-REPO-PATH
fatal: could not read Username for 'https://github.com': terminal prompts disabled

I find the the 3 sentences confusing since they mention classpath, a local folder, username, and terminal prompts disabled.

It would be great if it more clearly can express that no repo could be found with the provided URL, or at least remove the last sentence fatal: could not read Username for 'https://github.com': terminal prompts disabled which I find misleading.

Maybe the Unable to clone could be followed by the url instead of the local folder also?

why does clj -X pass in options as a clojure.lang.Symbol?

Mon, 25 Nov 2024 20:50:14 +0000

something i found counterintuitive recently is that clj -X passes in options as a symbols. so for example i have this function:
(defn test2 [opts] (println (type (:file opts))))
when i run clj like this:

-> clj -X some.package/test2 :file some-dir/file1

clojure.lang.Symbol

i would think it would be a string, so i'm curious why it's a symbol.

Is there a plan to have completion for "clojure" command?

Fri, 08 Nov 2024 12:54:01 +0000

It would be nice if I didn't have to remember all the tools I have installed and their options. They could be auto completed on command line.

I would like to have available tools listed when typing: clojure -T<tab><tab>
I would like to have specific tool functions listed when typing: clojure -Ttools <tab><tab>
I would like to have possible keys listed for given tool when typing clojure -Ttools show <tab><tab>

I was playing with bash completion a bit and sort of managed to do first 2:

$ clojure -T<tab><tab>
-Tantq      -Tclj-new   -Toutdated  -Ttools

$ clojure -Ttools <tab><tab>
install         install-latest  list            remove          show

using following script:

  #!/usr/bin/env bash

_clojure() {
  if [[ "${COMP_CWORD}" -eq 1 ]]; then
    local tools=($(clojure -Ttools list | tail --lines +2 | awk 'BEGIN {ORS=" "}{print $1}'))
    local options=()
    for tool in "${tools[@]}"; do
      options+=("-T${tool}")
    done
    COMPREPLY=($(compgen -W "${options[*]}" -- "${COMP_WORDS[COMP_CWORD]}"))
  elif [[ "${COMP_CWORD}" -eq 2 ]]; then
    local aliases=($(clojure -A:deps "${COMP_WORDS[1]}" help/dir))
    COMPREPLY=($(compgen -W "${aliases[*]}" -- "${COMP_WORDS[COMP_CWORD]}"))
  fi
}

complete -F _clojure clojure

I'm not saying that clojure necessarily needs to come with some completion script (although that would be nice), but It could come with features allowing to write such script.

It could e.g. read env variable GEN_COMPLETION that if set to 1 - clojure would print list of completions so one could request list of tools like this:

$ GEN_COMPLETION=1 clojure -T
-Tantq      -Tclj-new   -Toutdated  -Ttools

I believe there might be an issue knowing if "-T" is an argument or part of the argument, so there could be another env GEN_COMPLETION_CURRENT_ARG=0 indicating that -T is part we're completing (akin to COMP_CWORD in bash) which would be set to empty string or not present if we want to complete next argument in the command line.

As for completion for specific tools, they could provide some completion function that would be called when completing options of a specific tool.

How can I make Calva use a relative path when loading a file in cljs?

Mon, 23 Sep 2024 18:35:32 +0000

Is there a way to make Calva: Load/Evaluate Current File and its Requires/Dependencies use a relative path for ClojureScript instead of an absolute path?

I'm connecting to a docker container repl for development and the app is running at /app inside the container. Loading the current file in Clojure works as expected and evaluating things that have already been loaded in ClojureScript works as expected. Loading the current file in ClojureScript fails because it uses the host machine's full path. I get the following error:

; ------ REPL Error while processing ---------------------------------------------
; (cljs.core/load-file "/home/bmaddy/.../model/user.cljc")
; FileNotFoundException: /home/bmaddy/.../model/user.cljc (No such file or directory)

The following all work in the cljs repl as expected:

;; absolute path inside the container
(cljs.core/load-file "/app/src/.../model/user.cljc")
[]
;; relative path from project folder
(cljs.core/load-file "./src/.../model/user.cljc")
[]
(cljs.core/load-file "src/.../model/user.cljc")
[]

I see there are JACK_IN_PROJECT_ROOT_PATH and calva.replConnectSequences.projectRootPath settings, but they don't seem to affect this.

Some version info:
Calva version used: v2.0.474
clojure-lsp version used: 2024.08.05-18.16.00
VSCode Version: 1.93.1
OS: Linux

clojure is not starting on databricks file system (DBFS)

Thu, 19 Sep 2024 19:01:08 +0000

DBFS (databricks file system) is not properly implementing POSIX permissions.
Specially the bash flag "-w" fails to detect a non-writable project directory properly.

As a consequence in my case , starting clojure on DBFS tries to write the .cpcache to current dir, which is failing as it is in fact read-only, and this cannot be overwritten.

see here for details and error messages:
https://clojurians.slack.com/archives/C03S1KBA2/p1726750856210489

Changing unix file permission fails as well on DBFS

No way to specify Clojure version across all deps.edn files in a monorepo

Sun, 15 Sep 2024 19:46:47 +0000

Suppose you have deps.edn at the root and then a bunch of sub-directories with their own deps.edn files.

If you want to have a set of common dependencies for all of the projects, you can simply have e.g. a common directory where common/deps.edn specifies all of the common dependencies and all the rest of deps.edn files list common as one of their deps.

However, that doesn't work with org.clojure/clojure, making it implicitly special.

As I mentioned on Slack, it seems that clojure.tools.deps/root-deps brings the default top-level version of org.clojure/clojure and nothing else can override it but another top-level version.

Refresh/Reload deps.edn changes in Calva + VS Code in WSL Ubuntu

Mon, 19 Aug 2024 15:16:49 +0000

Hi, I am new to Clojure and am following this tutorial to make a Clojure API. This uses Cursive plugin in IntelliJ, but I am using Calva in VS Code.

This is my project structure:

 .
├── deps.edn
├── resources
│   └── config.edn
└── src
    └── clojure_api
        ├── config.clj
        └── core.clj

My config.clj file contents:

(ns clojure-api.config
    (:require [aero.core :as aero]
            [clojure.java.io :as io]))

(defn read-config []
  (-> "config.edn"
      (io/resource)
      (aero/read-config)))

I changed my deps.edn file to add the paths src & resources like this:

{:deps {aero/aero {:mvn/version "1.1.6"}} :path ["resources" "src"]}

while keeping the config.edn file an empty map: {}. However, I could not read the config file from read-config function in config.clj. It gave this error in Calva repl:

; Execution error (IllegalArgumentException) at aero.core/read-config-into-tagged-literal (core.cljc:194).
; Cannot open <nil> as a Reader.

The tutorial solved this error in Cursive by refreshing the project structure. I cannot seem to find any such commands in Calva. How can I update/refresh my project structure in Calva so that the deps.edn changes are reflected in the repl?

I have tried to restart the repl, reopening the folder in VS code, shuffling the resources directory around to no avail.

I could not find related answers to this problem after googling, so any help will be appreciated.

Using log4j-layout-template-json with Leiningen

Thu, 13 Jun 2024 07:58:28 +0000

Hi Everyone!

I have a wired issue with creating jar files using lein, I added a new log4j-layout-template-json to my project and add a JSON template for logging using org.clojure/tools.logging f everything was working well when I was running things locally but when I try to run the project from the jar file I keep getting this error

ERROR StatusConsoleListener Unable to locate plugin type for JsonTemplateLayout
ERROR StatusConsoleListener Unable to locate plugin for JsonTemplateLayout
ERROR StatusConsoleListener Could not create plugin of type class org.apache.logging.log4j.core.appender.ConsoleAppender for element Console: java.lang.NullPointerException: Cannot invoke "org.apache.logging.log4j.core.config.plugins.util.PluginType.getElementName()" because "childType" is null
 java.lang.NullPointerException: Cannot invoke "org.apache.logging.log4j.core.config.plugins.util.PluginType.getElementName()" because "childType" is null
    at org.apache.logging.log4j.core.config.plugins.visitors.PluginElementVisitor.findNamedNode(PluginElementVisitor.java:104)

So the project can't see the log4j-layout-template-json and I was able to make a working jar file by replacing /META-INF/org/apache/logging/log4j/core/config/plugins/Log4j2Plugins.dat with the file from the plugin itself so seems like the file gets overridden and the lein can't understand this Java plugin pattern
So the question here is there a way to automate this process with Lein or moving to deps could solve the issue, thank you!
project.clj file:

(defproject aa "aa"
  :description "FIXME: write description"
  :url "http://example.com/FIXME"
  :license {:name "EPL-2.0 OR GPL-2.0-or-later WITH Classpath-exception-2.0"
            :url "https://www.eclipse.org/legal/epl-2.0/"}
  :dependencies [[org.clojure/clojure "1.11.3"]
                 [org.clojure/tools.logging "1.2.4"]
                 [org.clojure/tools.cli "0.3.1"]
                 [org.clojure/core.async "1.3.610"]
                 [clj-commons/clj-yaml "1.0.26"]
                 [com.google.guava/guava "31.1-jre"]    
                 [io.netty/netty-all "4.1.107.Final"]
                 [org.clojure/core.match "1.0.1"]
                 [com.github.ben-manes.caffeine/caffeine "3.1.8"]
                 ;;;; Logging
                 [org.apache.logging.log4j/log4j-slf4j-impl "2.20.0"] ;; libraries using SLF4J won't complain
                 [org.apache.logging.log4j/log4j-api "2.20.0"]
                 [org.apache.logging.log4j/log4j-core "2.20.0"]
                 [org.apache.logging.log4j/log4j-layout-template-json "2.20.0"]]

  :jvm-opts ["-Dlog4j2.configurationFile=resources/log4j2.properties"
             "-Dlog4j2.garbagefreeThreadContextMap=true"
             "-Dclojure.tools.logging.factory=clojure.tools.logging.impl/log4j2-factory"]

  :test-selectors {:default (complement :integration)
                   :integration :integration}

  :main ^:skip-aot aa.core
  :target-path "target/%s"
  :profiles {:uberjar {:aot :all
                       :jvm-opts ["-Dclojure.compiler.direct-linking=true"]}})

Using this https://github.com/arctype-co/log4j2-plugins-cache plugin solves the issue for now but I want to know if there is a solution without including a new plugin

Does tools.deps treat a version (e.g. 1.2.3) as a range (i.e. [1.2.3,))?

Wed, 05 Jun 2024 16:53:59 +0000

Does tools.deps treat a version (e.g. 1.2.3) as a range (i.e. [1.2.3,)) like Maven and Gradle or like a fixed version (i.e. [1.2.3])? In addition, Maven has the concept of "soft" versions where the specified version is "preferred". Does tools.deps have a similar concept?

tools.tools install-latest throws sha error with :coord and never upgrades with :tool

Mon, 13 May 2024 10:24:47 +0000

Thanks for https://clojure.atlassian.net/browse/TDEPS-253, however I noticed it doesn't quite work as expected for a fresh install (with :coord); I get an error due to a missing sha, contrary to the doc string "git coords may omit sha".

clj -Ttools install-latest \
:lib org/tool-name \
:coord '{:git/url "git@gitlab.int.org.com:group/subgroup/tool-name.git"}' \
:as tool-name

=>
Execution error (ExceptionInfo) at clojure.tools.deps.extensions.git/eval1656$fn (git.clj:79).
Library org/tool-name has coord with missing sha

I also found upgrading a tool with saved coordinates (clj -Ttools install-latest :tool tool-name) always results in "Skipping, newest installed" (because passing the coord returned by parse-install-latest-args to install-1 means ext/find-all-versions is never evaluated). Looks like this issue would affect tools with auto resolved git urls too.

clojure -X:deps aliases fails for alias-as-data

Wed, 01 May 2024 05:35:46 +0000

(~/clojure/t)-(!2011)-> cat > deps.edn
{:aliases {:foo ["some" "data"]}}

Tue Apr 30 22:33:28
(~/clojure/t)-(!2012)-> clj
Clojure 1.12.0-alpha11
user=>

Tue Apr 30 22:33:37
(~/clojure/t)-(!2013)-> clojure -X:deps aliases
Execution error (ClassCastException) at clojure.tools.deps.cli.api/aliases$fn$fn (api.clj:170).
class java.lang.String cannot be cast to class java.util.Map$Entry (java.lang.String and java.util.Map$Entry are in module java.base of loader 'bootstrap')

Full report at:
/tmp/clojure-4544942395618193305.edn

Combining :exec-args from multiple aliases with user-defined semantics

Wed, 27 Mar 2024 12:32:27 +0000

I was looking for a way to invoke an nREPL server using clojure -X and specify extra dependencies and middleware in separate aliases which would be composed together on the command line.

For context: nREPL middleware are specified as a list of functions/runtime-resolved symbols, so ideally there would be some mechanism for each alias in the deps.edn to specify their own vector-of-middleware and have them concatenated in the order which the aliases were listed on the command line. (See below for concrete demonstration of this)

Unfortunately I couldn't find a satisfactory way of achieving this via the clojure CLI - the issue is that :exec-args maps from different aliases are simply merged, with latter values overriding earlier ones. The clojure.org reference mentions deep merging but this appears to be a doc error.

(Note that the widespread use of -M for this use case does not afford any way of composing command-line string args, forcing each alias to couple together all middleware and dependencies.)

Of course there shouldn't exist some magic set of semantics for merging exec-arg values (vectors => concat, maps => merge etc.)... Nevertheless there might be a usability gap to fill here, letting users specify their own merging semantics declaratively rather than having to resort to custom-coded task runners .

An example of how this would look like from the command line, given concat semantics for the :middleware arg:

$ clojure -X:nrepl
Starting nREPL server with: nil

$ clojure -X:nrepl :port 1234
Starting nREPL server with: {:port 1234}

$ clojure -X:cider:nrepl :port 5678
Starting nREPL server with: {:port 5678 :middleware [cider.nrepl/cider-middleware]}

$ clojure -X:portal:cider:nrepl
Starting nREPL server with: {:middleware [portal.nrepl/wrap-portal, cider.nrepl/cider-middleware]}

$ clojure -X:cider:cljr:portal:nrepl
Starting nREPL server with: {:middleware [cider.nrepl/cider-middleware, refactor-nrepl.middleware/wrap-refactor, portal.nrepl/wrap-portal]}

see this conversation in Slack thread for more context:
https://clojurians.slack.com/archives/C6QH853H8/p1711461045176759

Option in `clojure` CLI command to print the basis

Thu, 15 Feb 2024 13:57:44 +0000

It would be nice that clojure could print the basis for a given combination of aliases (or none).

A common use case is obtaining the computed :paths for a combination of aliases.

Add workspace level config

Wed, 14 Feb 2024 21:14:12 +0000

In our company we use a collection of projects. We want all of them to share common dependencies and aliases. For us it makes total sense to support additional config level most often called "workspace level" config in addition to other configs specified in https://clojure.org/reference/clojure_cli#deps_sources. Would it be possible to support that?

We've tried two workarounds:
- put shared config in the user level config. This approach has these problems: 1) there is nowhere to store user settings. 2) we had to modify CLJ_CONFIG to point to the location of the file.
- auto-generate deps.edn files for each project. This approach works but it generates a lot of updates whenever a shared dependency is changed. This also doesn't leave much room for custom project-specific or workspace-specific settings since every config file is auto-generated.

Race condition in .cpcache directory creation

Fri, 09 Feb 2024 00:24:08 +0000

As described in https://github.com/clojure/brew-install/pull/8, in our CI we need to run several clojure tasks for the same project in parallel. Which sometimes fails with

Refreshing classpath
Error building classpath. Can't create directory: /path/to/project/.cpcache

My understanding is that it is happening in https://github.com/clojure/tools.deps/blob/master/src/main/clojure/clojure/tools/deps/util/io.clj#L53-56 where we first check whether a directory exists and then create it.

(when-not (.exists parent)
  (when-not (.mkdirs parent)
    (let [parent-name (.getCanonicalPath parent)]
      (throw (ex-info (str "Can't create directory: " parent-name) {:dir parent-name})))))

If another process manages to create it after we checked for its existence, .mkdirs returns false and this process fails. A possible solution would be to check for the directory existence again like this:

(when-not (.exists parent)
  (when-not (.mkdirs parent)
    (when-not (.exists parent)
      (let [parent-name (.getCanonicalPath parent)]
        (throw (ex-info (str "Can't create directory: " parent-name) {:dir parent-name}))))))

Typo in :clojure.tools.deps.specs/claspath-args

Thu, 04 Jan 2024 16:44:22 +0000

Hi Alex,

I have a project in which I run tests with instrumentation turned on. The project has a dependency on tools.deps and I have the clojure.tools.deps.specs namespace loaded.

When I run the tests in my project they fail with the following error:

Unable to resolve spec: :clojure.tools.deps.specs/claspath-args

It looks like there is a typo in a the usage of a spec here:

https://github.com/clojure/tools.deps/blob/master/src/main/clojure/clojure/tools/deps/specs.clj#L151

I think it should use the ::classpath-args spec, instead of ::claspath-args.

Could you please take a look at this?

Thanks, Roman.

clojure cli bug on windows

Wed, 29 Nov 2023 01:21:42 +0000

The following command run fine on pwsh

clojure -Sdeps '{:deps {nrepl/nrepl {:mvn/version "1.0.0"} cider/cider-nrepl {:mvn/version "0.43.3"}} :aliases {:cider/nrepl {:main-opts ["-m" "nrepl.cmdline" "--middleware" "[cider.nrepl/cider-middleware]"]}}}' -M:cider/nrepl

But fails on powershell (windows powershell 5.1) , when ran on windows powershell, the double quotes are removed , hence to run it on windows powershell we need to escape the douvble quotes are run the following command instead

clojure -Sdeps '{:deps {nrepl/nrepl {:mvn/version ""1.0.0""} cider/cider-nrepl {:mvn/version ""0.43.3""}} :aliases {:cider/nrepl {:main-opts [""-m"" ""nrepl.cmdline"" ""--middleware"" ""[cider.nrepl/cider-middleware]""]}}}' -M:cider/nrepl

Also this second command fails on pwsh (powershell dotnet) because the strings are double double quoted

This issue, for me seem to be an issue with the clojure command, since as per the powershell docs, you should not need to escape double quotes inside a single quoted string

I found this issue as I was trying cider on emacs, cider by default creates the second command, and by default fails when using pwsh

Is this a problem than can be fixed, or should cider just handle pwsh different from powershell

Does the clojure cli have an option to include new extensions for dependency resolution?

Mon, 20 Nov 2023 13:31:36 +0000

From the source of tools.deps, I see that git and Maven is implemented via extensions and multimethods. Is there a way for someone to write a third-party extension and tell the clojure CLI tool to use it? e.g. an extension for SVN dependencies via :svn

My company has an internal build system that is not git or Maven based. It should be able to integrate with the current extensions framework within deps. However, I can't seem to find a way to tell clojure to load this extension file. It would be nice if we could configure via deps.edn or a flag when calling clojure to include other extension implementations.

In tools.deps, get the source of dependencies without downloading

Thu, 09 Nov 2023 17:01:03 +0000

When using the tools.deps API, I would like to resolve dependencies without downloading all of the jars, and I would like the return value to tell me the original URL of the dependency, rather than the path on disk.

The reason is I use bazel + https://github.com/griffinbank/rules_clojure, and if I have the URL, I can immutably cache artifacts in bazel, and have that cache be shared with all other developers at work.

Test suit doesn't find function implemented in my solution

Sun, 01 Oct 2023 14:05:15 +0000

I have submitted a solution to the bird watcher problem, and the test suit complains that it doesn't find the function day-without-birds. Visual Studio Code is able to import it and run it from another file.

The full implementation of the solution is as follows:

Solution

(ns bird-watcher)

 (def last-week [0 2 5 3 7 8 4])

 (defn last_position [v]
   (- (clojure.core/count v) 1))

 (defn today [birds]
   (get birds (last_position birds)))

(defn inc-bird [birds]
  (assoc birds (last_position birds)  (+ (today birds) 1)))

(defn day-without-birds
  [birds]
  (loop [y birds]
    (let [[x & rest] y]
      (if (= x 0)
        true
        (if (empty? rest)
          false
          (recur rest))))))
 
 

(defn n-days-count [birds n]
  (reduce + (take n birds)))

(defn busy [day]
  (if (> day 5)
    1
    0))

(defn busy-days [birds]
  (reduce + (map busy birds)))

(defn odd-week-internal
  [birds x]
  (loop [y birds
         target x]
    (let [[x & rest] y
          target (- 1 target)]
      (if (= x target)
        (if (empty? rest)
          true
          (recur rest target))
        false))))

(defn odd-week [birds]
  (odd-week-internal birds 0))

Thank you in advance!

Is tools.build considering adding a :license argument?

Fri, 29 Sep 2023 17:17:01 +0000

Now that Clojars requires licenses, projects that need to go up there need a license block in the pom files of their jars. Using build.tools it's possible to create a pom.xml, manually edit it to include a license section, then create a jar using that pom. But, that's manual.

Are there plans to add an option for write-pom (and gen-pom) to allow programmatic insertion of a license?

Tagged literals in Clojure CLI arguments and deps.edn

Tue, 12 Sep 2023 21:02:35 +0000

As it stands there is no way for the Clojure CLI to extend the reader with tagged literals for use within arguments or deps.edn.

I propose that some mechanism for this should be added, which can enable additional tooling to use the intended use case of putting data within aliases in deps.edn where they otherwise would be restricted by data readers.

An example of a current project which would benefit from this is Codox, which has support for regular expression based filters on namespaces to be documented, however as the default EDN reader does not include support for regular expressions, this feature is unusable.

If tagged literals support was added to the Clojure CLI, this problem could be resolved by a #jvm/regex tag or similar being added for that usecase.

If this feature is added it should also be considered what happens when a deps.edn file or argument to the CLI includes a tagged literal which is not bound in the current invocation.

There are multiple ways that support could be added to the CLI, and below I present a few of my own thoughts on the matter, but this is not a request for this to be the way that the feature is implemented, just some ideas.

Tagged literals could be added via aliases in the user deps.edn which are then used by default in all projects
Tagged literals could be specified by an environment variable, which users can then set with direnv or other tooling

clj/clojure scripts throws a stacktrace with unknown command-line argument

Thu, 31 Aug 2023 12:45:03 +0000

When clj or clojure is run with unknown argument (e.g. -v or -p) it will report this:

Execution error (FileNotFoundException) at java.io.FileInputStream/open0 (FileInputStream.java:-2).
-p (No such file or directory)

Full report at:
/tmp/clojure-814615935521714016.edn

Instead of throwing a confusing exception and stacktrace, it should report that command line argument is wrong and user should run --help for more options. Example of grep:

$ grep --xxx
grep: unrecognized option '--xxx'
Usage: grep [OPTION]... PATTERNS [FILE]...
Try 'grep --help' for more information.

Example of leiningen:

$ lein -xxx
'-xxx' is not a task. See 'lein help'.

Accepting "-" as argument to read non edn data fails with `-X` cli invocation

Tue, 29 Aug 2023 05:53:24 +0000

I have a clojure command line app that is invoked with -X. One of the conveniences is to allow "-" as a value which means to read from stdin. Currently, the data formats allowed are JSON and edn. This used to work, but now gives an error for non edn data:

Execution error at clojure.run.exec/read-args-stdin (exec.clj:152).
Invalid token: :

Here's an example usage:
https://github.com/phronmophobic/viscous

cat data.json | clojure -X:viscous :json-file -

I was able to find the commit where this changed, but this behavior doesn't seem to be documented anywhere (although it is very difficult to search for "-").

clojure.tools.deps/calc-basis can fail with "Unable to resolve" due to a version range

Sat, 26 Aug 2023 06:26:56 +0000

The following code:

https://gist.github.com/vemv/0254e4f594626b090520f1da323f9476

(I used a gist due to this site's 12000 character limit)

...will fail with:

Unable to resolve org.clojure/clojure version: [1.2.1],[1.3.0]
{:lib org.clojure/clojure, :coord #:mvn{:version "[1.2.1],[1.3.0]"}}

Perhaps it's worth noting that [org.clojure/clojure #:mvn{:version "1.11.1"}] is already explicitly specified.

I'm using org.clojure/tools.deps "0.18.1354".

Thanks - V

Support for binary resources and large resources via deps cli.

Fri, 25 Aug 2023 00:58:32 +0000

I've written a few libraries that depend on binary resources (eg. native shared libraries) and other libraries that have very large resources (eg. the llm weights for llama).

In principle, both of these types of dependencies can be satisfied by the deps tools without any changes since the deps cli can fetch resources and add them to classpath.

However, there are few additional challenges which makes using the deps cli for large and/or binary resources awkward.

Large resources are Large

I've avoided using the deps machinery for large resources because there are several affordances missing:

a) no yes/no prompt before downloading dependencies.

It seems reasonable to download maybe 100's of megabytes of dependencies when invoking the cli, but it doesn't feel right for the cli to download gigabytes of data dependencies without asking first

b) no progress indicator when downloading dependencies

Downloading dependencies is usually pretty quick, but it's nice to have a progress indicator if several gigabytes of dependencies are being downloaded.

Native dependencies are often large

Native dependencies can range from a few megabytes all the way to a gigabyte (eg. Chromium embedded framework).

Native dependencies are platform/OS dependent

I think there's some maven magic that helps with this which I haven't had a chance to look into. Anyway, the artifacts required for running depend on the platform that the program is running on. Usually, it's ok to include the artifacts for all possible platforms, but that may be unnecessarily using resources and might not work in particular cases.

Shared libraries must be extracted from jars before loading

Many ffi libraries (like JNA) will do this for you. It's implemented in an adhoc way depending on the ffi library. It may or may not work depending on whether the shared library is standalone or depends on other shared libraries.

Potentially, the deps tools could help extract shared libraries using an acceptable, uniform method.

Precompiled linux shared libraries barely work

It's possible to precompile shared libraries for mac osx and windows with a wide range of compatibility that "just work". With linux, there are lots of caveats. Generally, it seems like you can get something that mostly works if you have a standalone shared library and compile it with zig (eg. llmdb), but compatibility goes way down if there are multiple dependent shared libraries that don't use zig (eg. graphviz).

Native dependencies should be compiled from source?

Some package managers ship precompiled binaries (eg. conda), but it seems like many package managers tend to compile from source (eg. pip, macports, homebrew, etc).

Compiling from source may help with some of the following:

compiling from source sidesteps many of the challenges of providing native dependencies on linux
native deps could be git deps!
Some devs really dislike precompiled binaries and strongly prefer compiling from source.

Obviously, supporting compiling from source has its own challenges.

The above covers many of the problems with large and/or binary resources. Here are some concrete use cases:

clj-cef: wraps the chromium embedded framework. The framework itself is about 0.5-1.5gb depending on the platform and includes both shared libraries and large resource files. There's also an additional small, shared library required.
clj-graphviz: wraps the graphviz c libraries. Extra tricky because there are multiple shared libraries and each shared libraries have additional dependencies (eg. libpng).
llama.clj: wraps the llama.cpp library for running llms locally. It would also be nice to add specific llm weights as dependencies, but they can be very large (eg. a few gigabytes up to hundreds of gigabytes). Further, llama.cpp can be compiled with gpu support, but I haven't figured out how to do in a portable way without a compile from source option.

I know there's a lot of overlap with existing tools, so maybe there's some way for the deps cli to integrate with those existing tools:

fetching native deps: pip, conda, homebrew, macports, apt, scoop, etc.
fetching data dependencies: hugging face, https://dvc.org/

Anyway, I've made multiple attempts at finding a good approach for including native and/or large dependencies and all of the options still feel pretty awkward.

install-latest does not use coords to find versions in self-hosted git

Tue, 15 Aug 2023 11:11:52 +0000

clojure.tools.tools.api/install-latest (and clojure.tools.tools.api/install-1) don't pass the coord returned by clojure.tools.deps.tool/resolve-tool to clojure.tools.deps.extensions/find-all-versions.

This means it will never find versions for git libs hosted anywhere that isn't supported by clojure.tools.deps.extensions.git/auto-git-url.

It would be great if this was changed to support updating tools from non-standard git hosts.

Problem with leiningen and a local library

Sun, 13 Aug 2023 07:35:33 +0000

Hi,

I have two ClojureScript projects. From the first one (html-ui-lib) I created a JAR file with the following commands and installed it in a local repository:

lein with-profile prod jar
lein localrepo install -r /home/muenkel/soft/Global/clojure-repo target/html-ui-lib-0.1.2-SNAPSHOT.jar html-ui-lib 0.1.2-SNAPSHOT

In the second project (via-trans) I try to use this library. For this purpose I have included the library in the project file. Unfortunately, not all files of the JAR file are installed. What am I doing wrong?

Here is the content of the JAR file:

245 Fri Aug 11 00:02:34 CEST 2023 META-INF/MANIFEST.MF
3268 Fri Aug 11 00:02:34 CEST 2023 META-INF/maven/html-ui-lib/html-ui-lib/pom.xml
3183 Fri Aug 11 00:02:34 CEST 2023 META-INF/leiningen/html-ui-lib/html-ui-lib/project.clj
783 Fri Aug 11 00:02:34 CEST 2023 META-INF/leiningen/html-ui-lib/html-ui-lib/README.md
 0 Fri Aug 11 00:02:32 CEST 2023 META-INF/
 0 Fri Aug 11 00:02:32 CEST 2023 META-INF/maven/
 0 Fri Aug 11 00:02:32 CEST 2023 META-INF/maven/html-ui-lib/
 0 Fri Aug 11 00:02:32 CEST 2023 META-INF/maven/html-ui-lib/html-ui-lib/
158 Fri Aug 11 00:02:32 CEST 2023 META-INF/maven/html-ui-lib/html-ui-lib/pom.properties
 0 Fri Aug 11 00:01:30 CEST 2023 public/
 0 Tue Jul 11 23:15:06 CEST 2023 public/css/
2715 Tue Jul 11 23:15:06 CEST 2023 public/css/style.css
151 Sun Mar 26 21:35:54 CEST 2023 public/test.html
 0 Fri Aug 11 00:02:32 CEST 2023 public/cljs-out/
554 Mon Apr 17 22:11:34 CEST 2023 public/index.html
417 Sat Apr 08 23:03:08 CEST 2023 public/devcards.html
 0 Sat Jul 22 23:08:08 CEST 2023 html_ui_lib/
 0 Wed May 10 20:49:58 CEST 2023 html_ui_lib/util/
1100 Wed May 10 20:49:58 CEST 2023 html_ui_lib/util/limit-lines.cljs
1123 Thu May 04 23:27:52 CEST 2023 html_ui_lib/core.cljs
 0 Tue Jul 18 21:06:24 CEST 2023 html_ui_lib/spec/
272 Sun Jun 04 00:13:12 CEST 2023 html_ui_lib/spec/email-value-specs.cljs
1883 Tue Jul 18 21:06:24 CEST 2023 html_ui_lib/spec/value_specs.cljs
213 Wed Jun 07 23:31:32 CEST 2023 html_ui_lib/spec/text_value_specs.cljs
3871 Wed Jun 07 23:14:28 CEST 2023 html_ui_lib/spec/ui-specs.cljs
267 Wed Jun 07 23:26:06 CEST 2023 html_ui_lib/spec/number_value_specs.cljs
185 Sat May 20 23:56:54 CEST 2023 html_ui_lib/spec/date_value_specs.cljs
178 Wed May 31 00:26:16 CEST 2023 html_ui_lib/spec/drop_down_value_specs.cljs
1545 Mon Jul 17 22:55:08 CEST 2023 html_ui_lib/spec/type_specs.cljs
 0 Tue Jul 18 20:59:58 CEST 2023 html_ui_lib/ui/
3234 Tue Jun 06 21:32:30 CEST 2023 html_ui_lib/ui/input_email.cljs
4298 Tue Jul 18 20:59:58 CEST 2023 html_ui_lib/ui/tree_view.cljs
3361 Wed May 24 22:41:30 CEST 2023 html_ui_lib/ui/input_text.cljs
3420 Sat Jun 03 21:42:24 CEST 2023 html_ui_lib/ui/input_date.cljs
6013 Wed Jun 07 23:35:28 CEST 2023 html_ui_lib/ui/input_number.cljs
2029 Wed Jul 12 22:42:44 CEST 2023 html_ui_lib/ui/core.cljs
396 Fri Apr 07 21:19:26 CEST 2023 html_ui_lib/ui/button.cljs
844 Tue Jul 11 23:13:50 CEST 2023 html_ui_lib/ui/output_boolean.cljs
1127 Wed Jul 12 23:57:34 CEST 2023 html_ui_lib/ui/input_checkbox.cljs
276 Sun Apr 23 22:59:54 CEST 2023 html_ui_lib/ui/grid_container.cljs
603 Thu Jun 08 22:50:00 CEST 2023 html_ui_lib/ui/output_number.cljs
1613 Mon Jul 10 21:58:34 CEST 2023 html_ui_lib/ui/input_radio.cljs
381 Sun Apr 09 00:16:22 CEST 2023 html_ui_lib/ui/table.cljs
1775 Sat Jul 01 22:19:10 CEST 2023 html_ui_lib/ui/drop_down_list.cljs
2789 Wed Jun 28 22:57:44 CEST 2023 html_ui_lib/ui/leaf_template.cljs
313 Thu Jun 08 23:19:22 CEST 2023 html_ui_lib/ui/output_text.cljs
2160 Thu Jul 13 23:36:30 CEST 2023 html_ui_lib/ui/input_password.cljs
519 Wed Jun 07 22:44:34 CEST 2023 html_ui_lib/test_runner.cljs
860 Wed Jun 07 22:57:28 CEST 2023 html_ui_lib/number_value_specs_test.cljs
273 Wed May 24 21:17:16 CEST 2023 html_ui_lib/text_value_specs_test.cljs
1090 Tue May 30 23:24:06 CEST 2023 html_ui_lib/value_specs_test.cljs
7280 Wed Jun 07 23:07:38 CEST 2023 html_ui_lib/ui_specs_test.cljs
2274 Wed May 24 21:37:08 CEST 2023 html_ui_lib/type_specs_test.cljs
305 Wed May 24 23:44:04 CEST 2023 html_ui_lib/drop_down_value_specs_test.cljs
260 Sun Mar 26 21:35:54 CEST 2023 html_ui_lib/core_test.cljs

Here, on the other hand, is the content of the directory with the library. As you can see, only the files of the namespace ui are contained here:

via-trans/resources/public/cljs-out/dev/html_ui_lib/
└── ui
    ├── core.cljs
    ├── core.cljs.cache.json
    ├── core.js
    ├── core.js.map
    ├── input_text.cljs
    └── input_text.js

Here is the project.clj file of html_ui_lib:

(defproject html-ui-lib "0.1.2-SNAPSHOT"
:description "FIXME: write this!"
:url "http://example.com/FIXME"
:license {:name "Eclipse Public License"

        :url "http://www.eclipse.org/legal/epl-v10.html"}

:min-lein-version "2.7.1"
:dependencies [[clj-commons/citrus "3.3.0"]

             [cljs-ajax "0.8.1"]
             [funcool/struct "1.4.0"]
             [org.clojure/clojure "1.10.0"]
             [org.clojure/clojurescript "1.11.60"]
             [rum "0.12.10"]]

;;:deps {io.github.clj-kondo/config-rum-rum {:mvn/version "0.12.10"}}
:global-vars {warn-on-reflection true}
;;:global-vars {asserts false}
:source-paths ["src/cljs" "test/cljs"]
:aliases {"fig:build" ["trampoline" "run" "-m" "figwheel.main" "-b" "dev" "-r"]

        "fig:min"   ["run" "-m" "figwheel.main" "-O" "advanced" "-bo" "dev"]
        "prod:build" ["run" "-m" "figwheel.main" "-O" "advanced" "-bo" "prod"]}

:profiles {:dev {:dependencies [[com.bhauman/figwheel-main "0.2.18"]

                              [org.slf4j/slf4j-nop "1.7.30"]
                              [com.bhauman/rebel-readline-cljs "0.1.4"]
                              [devcards "0.2.7"]
                              ;; for informing the linter clj-kondo, that the macros
                              ;; defc etc defines symbols
                              [io.github.clj-kondo/config-rum-rum "1.0.0"]]
               :source-paths ["devcards/cljs"]
               :resource-paths ["target"]
               ;; need to add the compiled assets to the :clean-targets
               :clean-targets ^{:protect false} ["target" "resources/public/cljs-out"]
               #_:global-vars #_{*asserts* false}}
         :prod {:dependencies [[com.bhauman/figwheel-main "0.2.18"]]
                :compiler {:optimizations :advanced
                           :pretty-print false}
                :clean-targets ^{:protect false}
                ["target"
                 "resources/public/cljs-out/prod"
                 "resources/public/cljs-out/prod-main.js"]
                :cljsbuild {:builds
                            [{:source-paths ["src/cljs"]
                              :compiler
                              {:output-to "resources/public/cljs-out/prod-main.js"
                               :optimizations :advanced
                               :pretty-print false}
                              :build nil}]}
                :plugins [[lein-cljsbuild "1.1.8"]]}}

:plugins [[com.github.clj-kondo/lein-clj-kondo "0.2.4"]

        [com.fabiodomingues/lein-clj-depend "0.3.0"] ;; Usage: lein clj-depend
        ;; Detects curcular referencies
        [lein-kibit "0.1.8"] ; Code Analyzer: https://github.com/clj-commons/kibit
                                    ; Anounced better code alternatives
                                    ; Usage: lein kibit
                                    ; Automatic: lein auto kibit
                                    ; With replace: lein kibit --replace --interactive
        ])

Here is the project file of via-trans:

(defproject via-trans "0.1.0-SNAPSHOT"
:description "FIXME: write description"
:url "http://example.com/FIXME"
:dependencies [;;[camel-snake-kebab "0.4.3"] ; Libray used for converting keywords

             [ch.qos.logback/logback-classic "1.4.4"]
             [cljs-ajax "0.8.1"]
             [clj-commons/citrus "3.3.0"]
             ;;[clojure.java-time "1.1.0"]
             ;;[cljc.java-time "RENAMED"]
             [cljc.java-time "0.1.18"]
             [conman "0.9.6"] ; Library used for creating functions from sql
             [cprop "0.1.19"]   ; Configuration
             [devcards "0.2.7"]
             [expound "0.9.0"]
             [funcool/struct "1.4.0"]
             [com.layerware/hugsql "0.5.3"] ; Replacement for conman
             ;[hugsql-adapter-case "0.1.0"] ; case adapter for db table columns 
             [html-ui-lib "0.1.2-SNAPSHOT"]
             [json-html "0.4.7"]
             [luminus-transit "0.1.5"]
             [luminus-undertow "0.1.18"]
             [luminus/ring-ttl-session "0.3.3"]
             [org.mariadb.jdbc/mariadb-java-client "1.1.5"]
             ;;[mysql/mysql-connector-java "8.0.18"]
             [markdown-clj "1.11.3"]
             [metosin/muuntaja "0.6.8"]
             [metosin/reitit "0.5.18"]
             [metosin/ring-http-response "0.9.3"]
             [mount "0.1.16"]
             [nrepl "1.0.0"]
             [org.clojure/clojure "1.11.1"]
             [org.clojure/clojurescript "1.11.60"]
             [org.clojure/tools.cli "1.0.214"]
             [org.clojure/tools.logging "1.2.4"]
             [org.webjars.npm/bulma "0.9.4"]
             [org.webjars.npm/material-icons "1.10.8"]
             [org.webjars/webjars-locator "0.45"]
             [org.webjars/webjars-locator-jboss-vfs "0.1.0"]
             [ring-webjars "0.2.0"]
             [ring/ring-core "1.9.6"]
             [ring/ring-defaults "0.3.4"]
             [rum "0.12.10"]
             [selmer "1.12.55"]]

:min-lein-version "2.0.0"
:source-paths ["src/clj" "src/cljc" "src/cljs" "devcards/cljs"]
:test-paths ["test/clj" "test/cljc" "test/cljs"]
:resource-paths ["resources" "target"]
:clean-targets ^{:protect false} ["target" "resources/public/cljs-out"]
:target-path "target/%s/"
:main ^:skip-aot via-trans.core
:plugins []
:profiles
{:uberjar {:omit-source true

         :aot :all
         :uberjar-name "via-trans.jar"
         :source-paths ["env/prod/clj" ]
         :resource-paths ["env/prod/resources"]}

:dev [:project/dev :profiles/dev]
:test [:project/dev :project/test :profiles/test]
:project/dev {:jvm-opts ["-Dconf=dev-config.edn" ]

              :dependencies [[com.bhauman/figwheel-main "0.2.18"]
                             [com.bhauman/rebel-readline-cljs "0.1.4"]
                             [org.clojure/tools.namespace "1.3.0"]
                             [pjstadig/humane-test-output "0.11.0"]
                             [prone "2021-04-23"]
                             [ring/ring-devel "1.9.6"]
                             [ring/ring-mock "0.4.0"]]
              :plugins      [[com.jakemccrary/lein-test-refresh "0.24.1"]
                             [jonase/eastwood "1.2.4"]
                             ;;[cider/cider-nrepl "0.28.4"] ; ist in .lein/profiles.clj
                             ]   
              :source-paths ["env/dev/clj" ]
              :resource-paths ["env/dev/resources" "target"]
              :repl-options {:init-ns user
                             :timeout 120000}
              :injections [(require 'pjstadig.humane-test-output)
                           (pjstadig.humane-test-output/activate!)]}

:project/test {:jvm-opts ["-Dconf=test-config.edn" ]

              :resource-paths ["env/test/resources"] }

:profiles/dev {}
:profiles/test {}})

Unable to locate a Java Runtime

Sat, 29 Jul 2023 18:13:11 +0000

I try to learn Clojure and follow Clojure for the Brave and True book.

In core.clj file, I typed M-x cider-jack-in command. I see following error:

error in process sentinel: Could not start nREPL server: The operation couldn’t be completed. Unable to locate a Java Runtime.

I tried both 8 and 17 versions of Java, I verified them via which java and echo $JAVA_HOME

Lein commands works by themselves.

Can you help me?

make-classpath2 in tools.deps cannot be run from a directory other than the project one

Fri, 14 Jul 2023 13:49:38 +0000

In Cursive's new deps integration, I invoke make-classpath2 from within IntelliJ, which means that the CWD is not the project directory. I bind clojure.tools.deps.util.dir/*the-dir* when I do this, and most things work correctly. However, there are some exceptions which don't work:

:mvn/local-repo
:local/root deps inside :override-deps
:classpath-overrides

It would be nice if they could be made to work too. If there's interest in a patch for this I could have a go at it.

Path to installed man pages by Clojure POSIX installer script

Thu, 13 Jul 2023 21:54:57 +0000

The POSIX installer worked great for me on OpenBSD, thank you!

The resulting man pages were located in /usr/local/share/man which is not documented AFAICT (maybe I am wrong about this?)

Proposed solution: Add that path to the documentation.

Feature request for Clojure CLI: Some way to specify OS-conditional values for :local/root in deps.edn

Sat, 08 Jul 2023 12:57:54 +0000

This problem arose trying to run a Clojure project on WSL2 from a project originally built on Windoze.

The original :local/root paths started with "C:/..." but on WSL2 (running Ubuntu 22) they need to be converted to "/mnt/c/..." to run.

Manually changing them makes them work, but it's a hassle. Won't even mention source control woes.

Imagining automatic conversion rules feels dreadful, it would be better if we could simply specify OS-specific values. Maybe something like:

{some.ns/some-lib {:local/root 
                    {:local-path/windows "C:/..." 
                     :local-path/linux "/mnt/c/..." 
                     :local-path/macos "/some/other/dev/path"}}}

At runtime, the correct local-path should be selected for the value based on the OS on which the JVM is running.

Surely this can also be a problem on MacOS running Parallels, where file system integration is also tight but the Guest OS can have different values for the same paths on the Host. And knowing what these might be a priori is probably not practical, given the Cambrian explosion of Linux distributions, Windows editions, and MacOS versions. It would be the developer's responsibility to set these values based on a concrete development setup. So, IMHO, it would be enough optionally to offer some ability to provide a map with certain high-level OS options in place of a string.

It also seems obvious to me that these values will always be developer-centric and possibly subject to employer devops policies.

(Yes, this is my implementation bias, but I would gladly support any general way to handle this problem.)

Could the CLI check for the latest stable version?

Mon, 19 Jun 2023 18:49:58 +0000

Given the number of people (mostly beginners) who seem to run into problems with the CLI because they have an older version and are following either newer instructions or trying to use libraries that rely on newer features, I wonder whether it would be worth adding a check to the script that would output a warning if the current stable version is more recent (from the download site)?

I know that won't help people who already have an old version installed but it would at least help future people...

...or is the command-line "API" stable enough at this point that it wouldn't be worth it?

Examples include the changing semantics for both -M and -T over the years, support for :git/sha (vs :sha), and several other changes, both in tools.deps itself and the CLI script.

incorrect test? clojure.tools.deps.test-deps/test-dep-choice

Thu, 18 May 2023 04:01:47 +0000

test-dep-choice

There is no call to is, so test succeeds trivially.
I think the correct value to compare against should be {:a "1", :b "1", :c "2"} instead of {:a 1, :b 1, :c 2}, looking at other tests in this area.

proper XDG support

Wed, 03 May 2023 03:05:05 +0000

XDG_CONFIG_HOME does not need to be set explicitly, and tools follow XDG spec should just write to $HOME/.config/clojure

Right now, if XDG_CONFIG_HOME is not set, it just writes to $HOME/.clojure

more context here also:
https://clojureverse.org/t/opinion-about-xdg-support-by-the-clojure-tools-deps-cli/9814/3

Shutdown Morse Gracefully?

Mon, 01 May 2023 18:20:15 +0000

I will be starting it many times per day -is that safe? If not, how does one shutdown morse gracefully?

Installing Clojure

Wed, 26 Apr 2023 08:43:10 +0000

Well, I followed advise from the Clojure Workshop and installed Leiningen that came with its own REPL.

I also followed on-site advise to install ClojureTools using Powershell.

I also have Calva and other Clojure extensions installed on VS Code.

Could I suggest that a ClojureTools.msi file be created, so that installing Clojure can be a painless action.

Specify a custom classpath

Wed, 19 Apr 2023 23:59:18 +0000

As a way to deal with concurrency issues when compiling several projects in parallel I introduced a temporary compilation folder for each clojure instance (which is then merged with the primary cache in an atomic file move). The simplest way to specify this folder to JVM is by passing it on the command line. Unfortunately, when I run clojure using clojure script there seem to be no option to pass an extra classpath item. Would be great to introduce it. Something like:

clojure -Saddcp=/tmp/classes215632

that ends up adding /tmp/classes215632 to the overall classpath generated from deps.edn file.