First, wanted to thank @seancorfield for his dot-clojure. 😄 Also wondering if tools.deps has anything similar to leiningen's :injections functionality?

no

instead of running a repl, you could launch your own program that started its own repl that did something similar

ack. are there any workarounds? something as simple as (require '[clojure.pprint :refer [pp]]) could save a lot of typing over time.

True. I'm in the process of converting from emacs/cider to vim/conjure. I'll pursue that route.

Thank you!

like clojure.main effectively just does this:

(repl :init (fn []
              (initialize args inits)
              (apply require repl-requires)))

the initialize part will already be handled by the main wrapper, so don't need that line

you'd want to supply the :eval hook: #(do (injections) (eval %))

something like that, the default is just eval

... I'm afraid that's a little beyond my level of knowledge of the repl/clojure.main at the moment, but I'll take some time this week to dig in to how that would work in practice.

that's all the code

Appreciated, nonetheless!

the eval hook is defined in deps.edn?

as a command line:

clj -e "(require '[clojure.main :as m]) (m/repl :init #(apply require m/repl-requires) :eval (fn [form] (do (require '[clojure.pprint :refer [pp]]) (eval form))))"

which you can then fold into an alias if you like

;; deps.edn:
{:aliases {:repl {:main-opts ["-e" "(require,'[clojure.main,:as,m])(m/repl,:init,#(apply,require,m/repl-requires),:eval,(fn,[form],(do,(require,'[clojure.pprint,:refer,[pp]])(eval,form))))"]}}}

then clj -A:repl

you could fold that tiny program into a tool that abstracted out the injections rather than hard-coding them and clean this up a bit, but that's the core of it

Wait... pp is available directly in the REPL started by clj already...

> clj
Clojure 1.10.1
user=> *clojure-version*
{:major 1, :minor 10, :incremental 1, :qualifier nil}
user=> (pp)
{:major 1, :minor 10, :incremental 1, :qualifier nil}
nil
user=> 

@penryu What injections do you want in the Clojure REPL, specifically? (given that pp already seems to be referred in by default)

it's only available in user

injections makes it available in every ns

I dropped the above in a blog in case it's helpful for posterity https://insideclojure.org/2020/02/11/custom-repl/

and so I can just point someone to it next time :)

Thanks for the explanation, @alexmiller!

@seancorfield might also be something like tools.logging or spyscope (as recommended in a post), though I’m having problems getting either of them to work right now.

(I never used :injections in all the years I used Leiningen and I'm not sure not sure I'd want a bunch of symbols auto-inserted into every namespace while I'm working so...)

Yes, it would need to be sparse in the extreme. But certain things (like pp or #spy) might be reasonable. And I intended to bury it behind an alias (`-A:spy:rebel` or just fold it into rebel) anyway, never in a clean clj session.

What is the reason the Corfield comma is necessary in the first place?

Round-tripping to text files and back into bash (and then into Clojure as command-line arguments).

(shell escaping is... )

is there a technical reason it can not be done with full fidelity, or has no one dived into the GNU Bash Info page?

or whatever Windows uses for bash 😂

which I think is now... bash

I suspect it could be done with full fidelity, but the prevalence of multiple different versions of bash on Mac OS versus different flavors of Linux adds a level of difficulty to the problem. Also not just spaces, but single and double quotes, dollar signs, braces, ... It can make a grown person weep.

Not sure it is a hill I want to even try to climb, nor die on.

@ghadi I'm sure Alex would welcome patches for it 🙂

"It's hard!" is the technical reason I've heard from several people.

I suspect it would be difficult to maintain the shell scripts, too, and lead to copious notes on what works and what doesn't across the platforms.

I'm thinking of tools that accept main arguments (like Docker) usually accept a canonical form: an array of strings (which is sort of punting)

The complexity comes from clojure storing all that stuff in text files in .cpcache and then reading it back on subsequent runs.

I know reasonable people might disagree with this statement, but bash is just barely a programming language.

I will end my rant-ish statements on that topic for the evening 🙂

I actually have a recently raised alternative to the spaces issue that avoids all the escaping that I’m exploring.

Raised by rich and Stu for other purposes but happens to also cover this

@deleted-user Then you should write up a patch for clojure and/or tools.deps.alpha that fixes these problems 🙂

cuz this is ridiculous: https://github.com/clojure/tools.deps.alpha/wiki/clj-on-Windows#escaping-quotes

but actually, may be that's a diff issue?

At what point is it worth reading code from a file instead of a command line argument? It seems tools.deps has drawn that line in the sand.

Expanded version of my earlier question about javac: suppose I want to get in between the resolve-deps and make-classpath steps before running clj, say to do some other processing on files fetched from git, add resulting artifacts to the classpath. Are there any examples of tools (or whatever) doing such?

Not that I'm aware of, that's a new, separate tool.

However, I think that would be really useful for the javac case.

Other tools are generally shell scripts which you run first, but that reduces the smooth integration with cider, etc.

OK, I do not have stats weighted by number of http://Clojars.org project downloads right now, but I do have some stats showing that out of 11,736 Github projects I successfully cloned, and that is the subset of them that have a project.clj file but no deps.edn file in their root directory, 91.8% of those project.clj files were readable using clojure.edn/read , and had their defproject form first, and a reasonable-looking value for the :dependencies key (or no dependencies key, which is completely correct and fairly common). More data and steps I used to collect it here: https://github.com/jafingerhut/haironfire

cool (and nice repo name :)

The most common reason that a project.clj file threw an exception while attempting to use clojure.edn/read to read its contents: regex literals are not valid EDN. Those are reasonably common in project.clj files, for things like jar inclusions/exclusions, or other kinds of file name selection sets.

that's kind of interesting

I wonder if you could hack the edn reader to read those into tagged literals or something

how much additional % does that cover?

Good question, which I thought of attempting, but haven't yet. That was the first thing in the project.clj file that caused clojure.edn/read to throw, and there could be others after that, which would only be straightforward to calculate with such a modified version of clojure.edn/read

such a thing could possibly even make its way into clojure's real edn reader

regexes aren't portable though

I didn't say make it into edn

there are lots of things the clojure edn reader does beyond the edn spec

hmmm.jpg

and I'm not suggesting reading it into java pattern, but into a tagged literal

same thing for the var dispatch I was talking to you about

#regex or whatever

less sure on vars if that makes sense as you're then connecting to code

(tangent, but I want to have the choice of whether to connect to code or read as tagged)

Edamame can read regex I think

Based on the numbers I have seen, if the project.clj files that threw exception due to regex are edn-readable in all other ways except the regex literals, I think the most the numbers above could improve would be from current 91.8% up to close to 95% or 96%, but that would be noticeable, I think.

Sounds like a straightforward thing to hack up locally on my system. I will let you know if I try it out. If anyone hacks up a version of clojure.edn/read before I do, let me know.

https://github.com/clojure/tools.reader/blob/master/src/main/clojure/clojure/tools/reader/edn.clj#L345-L354

@andy.fingerhut you could switch to tools.reader and monkey patch that to read regex + vars

Cool, that may be the quickest way.

naughty, but straightforward

Maybe I should take the opportunity to see if clojure.edn/read and tools.reader edn reader behave differently on any of these 11,736 files 🙂

on a tangential note perhaps, regarding regexes -- there's the regal thing that expresses regexes using plain clojure data: https://github.com/lambdaisland/regal

this is about existing data in project.clj files, so I don't think that helps anything

you're talking about converting regexes as well as whether the result is valid edn, no?

anyway, for future cases, it could be useful for folks to express their regex using regal and having a file that is more likely to be edn?

Fraction of the 11,736 project.clj files that become 'good' in my experiments (readable using clojure.edn/read without throwing exceptions, defproject form is first, value of dependencies key looks reasonable) goes up from 91.8% to 95.7% with a hacked up version of EdnReader class that can read regex literals. Details here: https://github.com/jafingerhut/haironfire/blob/master/README-extended-edn-reader.md

I mean, beyond the regex literals