Really enjoying babashka. Life's too short to remember how to write bash code. I feel liberated. Thanks a million @borkdude!

@deleted-user borkdude may be around later to give you an answer

@deleted-user can you give an example of what exactly you need and why you need it in an issue?

I’m not aware that Clojure itself provides the name of the current file, but it does provide the name of the current namespace

Due to a typo re-quote-replacement is not available... I'll fix the typo. Sorry about that 🙂

Fixed on master:

$ lein bb '(clojure.string/re-quote-replacement "string \\ $")'
"string \\\\ \\$"

Ah, Clojure can do this:

(def x 1)
(println (:file (meta #'x)))

$ clj /tmp/foo.clj
/tmp/foo.clj

https://github.com/borkdude/babashka/issues/177

bb 0.0.44: https://github.com/borkdude/babashka/releases/tag/v0.0.44

Here's a list of breaking changes so far: https://github.com/borkdude/babashka/blob/master/CHANGES.md

@plexus Is your blog open source? If you're open to it, I could do a PR to update *in* to <input>

I added a list of currently known blog articles about babashka: https://github.com/borkdude/babashka#blogs

Considering clj-http-lite for bb:

$ bb "(require '[clj-http.lite.client :as client]) (:status (client/get \"\"))"
200

Rationale: idiomatic http client. clj-http has been around for a long time, "defacto" lib, but vanilla clj-http doesn't work with GraalVM. clj-http-lite is the GraalVM version that comes closest

Alternative: expose necessary Java classes to build your own requests (but contrary to java.time that seems tedious)

I like it

$ bb -e "(require '[clj-http.lite.client :as client]) (client/post \"\" {:body (json/generate-string {:a 1})})" | bb '(keys <input>)'
(:headers :status :body)

maybe adding the client default alias makes sense

or http.client maybe?

Naming is really the hardest problem

Binaries with clj-http-lite included: Linux: https://2646-201467090-gh.circle-artifacts.com/0/release/babashka-0.0.45-SNAPSHOT-linux-amd64.zip Mac: https://2647-201467090-gh.circle-artifacts.com/0/release/babashka-0.0.45-SNAPSHOT-macos-amd64.zip Branch: clj-http

yeah maybe I'll leave out a default alias altogether then

@deleted-user Again, could you give an example (or maybe an issue) with how that is supposed to work? I commented on it above

@deleted-user If you mean the joker.filepath namespace: there is support for Java interop in babashka for .File, java.nio.* + the namespace. This should give you what you need while also maintaining compatibility with normal Clojure

it's nice to be able to make symlinks for sure -- unfortunately, recent experiments suggest this won't work on windows 10 until jdk 13 😞

this was what i was trying: https://gist.github.com/sogaiu/cfa1484d9c3ca875b13f0c3ac75c6c73

@sogaiu are you using Windows a lot?

i use it to test what i'm building

@sogaiu what about using WSL(2)

wsl2 is not an option yet iiuc -- also i am using vms where it is questionable whether it will be practical to use.

https://docs.microsoft.com/en-us/windows/wsl/wsl2-install

it seems to be "Insider" right

but wsl1 is there already

why go to the old thing?

i like the idea of being able to determine the current file location. (as a side note, unless it's going to be a dynamic var, i'm not a fan of using the earmuffs.)

is it a dynamic var in joker? I think it could be <file>, since we already have <input>

although clojure has *command-line-args* which is a bit inconsistent I guess, but maybe that was introduced before the earmuffs convention

Neh, I'm going to try to be compatible with clojure as much as I can

@deleted-user What is the value of file in a script that you use with require in joker

ok

Oh btw, it seems like *command-line-args* is a dynamic var:

(binding [*command-line-args* 2])

Darn. Maybe it makes sense to introduce *input* instead of <input> then, because it will be bound by babashka itself to some value

And call <file> just *file*

Welcome to joker v0.14.0. Use EOF (Ctrl-D) or SIGINT (Ctrl-C) to exit.
user=> (binding [*file* 2])
nil

as long as the thing is going to be a dynamic var and not change its name, i think it makes sense to use the earmuffs

yeah, that hadn't occurred to me when renaming *in* to *input*

(which wasn't and isn't a dynamic var, but can be made so)

yeah, that's why it isn't 0.1 yet.. still figuring this out 🙂

i haven't played enough with *in* / *input* / <input> to have an opinion about whether it should be a dynamic var -- may be other people are in a better position to have an informed opinion 🙂

well, <input> is really a delay which will be realized the first time it's evaluated

so if you don't use <input> in your program, it won't block, waiting for input

but if you use it twice, it will be bound to the same value

$ echo 2 | bb '(* <input> <input>)'
4

it depends on the command line options iiuc

@deleted-user It reads EDN by default

it does so by default to make chaining EDN expressions more succinct

I think keeping the notation for <input> might make sense, since it is a bit magic in this respect

instead of *file* which is just an ordinary dynvar

look at the babashka tests, I haven't found the need for that

just feed input to the script

with with-in-str etc

This is more for one-liners, not really for scripting, where you can just use read-line et al

yes

babashka started out as a tool to do just little sprinkles of clojure in between bash expressions, but now it's growing more towards a full scripting solution

i have a similar interest -- am hoping eventually for a crossplatform solution. don't want to maintain (or write) both bash and powershell.

...and i'd much prefer to write in something clojurish 🙂

i think babashka could really be a great way to learn clojure too

or at least get started

like with every new shiny tool probably

This tool is less than 6 months old.

PR welcome

Thank you. Yes, it's not perfect yet, and the more exposure it gets, the better it gets hopefully

sent!

@borkdude including clj-http-lite is a great idea

@deleted-user Right, we could use the --classpath option you mean?

@deleted-user No, a classpath is just a collection of directories and jar files that will be searched for a matching file

I guess you can also just provide that as an argument to the script?

which makes the script also more flexible

@deleted-user There's a workaround for that:

$ cat script.clj
#!/bin/sh

#_(
   "exec" "bb" "$0" hello "$@"
   )

(prn *command-line-args*)

./script.clj 1 2 3
("hello" "1" "2" "3")

(arguments in shebang that is)

Right now you can also use: /tmp/foo.clj (chmod +x)

#!/bin/sh
#_(
   "exec" "bb" "$0" "$0" "hello" "$@"
   )
(prn *command-line-args*)

$ /tmp/foo.clj

("/tmp/foo.clj" "hello")

it's a bit hacky, but it works

In normal Clojure, you could probably read the metadata from a var and inspect the :file property. Have you tried if this works? If it does, we can just do that.

clj-http-lite is going to obsolete my awesome curl wrapper! oh well 🙂

@laheadle You can still use curl 🙂

@deleted-user Where do you read this? Vars were recently introduced

Removed that, thanks

So would adding :file to that solve your problem?

It would be good to see what clojure makes of it, when you execute clojure script.cljc

from various locations

like others, I find myself writing slightly larger scripts than the few-liners that glue together chunks of bash.

@deleted-user This seems to work for getting the scripting directory using clojure:

(def x)
(require '[ :as io])
(def script-dir (.getParentFile (io/file (:file (meta #'x)))))

Someone also mentioned https://github.com/schmee/java-http-clj which relies on JDK 11

might be good to explore before adding clj-http-lite

You could give it a try, but it requires some understanding of how files are processed either with passing a file argument, load-file and require. The way we handle classpath loading with a callback fn needs to change as well. I think it would be best if I gave it some more hammock time first

The logic is spread across babashka, the sci library and the edamame parser library

Each of these, or at least two, probably require changes

here's where I am on this script. ~/Sync/dotfiles is where the script sits and subdirectories have the dotfiles:

@sogaiu I added a table to illustrate the combinations of input and output flags: https://github.com/borkdude/babashka/#input-and-output-flags

oh, nice! :thumbsup:

Small follow up to this morning's breaking change: https://github.com/borkdude/babashka/releases/tag/v0.0.45

I hope this only counts as one 🙂