I'm not sure if cider already have the capacity to do something like that, but you might want to look at https://github.com/clojure-emacs/parseedn to get data out of deps.edn

Awesome, you preceded my question 👌:skin-tone-4:

You could also shell out to babashka and write normal clojure :) I normally work with EDN like that.

This was actually my first thought, call a script and reach for the result in emacs

I‘m looking for the how to do that atm since my emacs foo is lacking 😅

Mine too 😂 Way more comfortable in clojure.

Haha, exactly… :rolling_on_the_floor_laughing:

I can dig up some of my code when I'm in front of a computer in an hour or so

That‘d be awesome!

Cider does this for shadow I think. You could just modify that

Oh, didn’t know that… will have a look there

Thx

Just found it in the docs. Cider jack in cljs does parse it from the shadow-Cluster file

https://github.com/clojure-emacs/cider/blob/master/cider.el#L854

Should be similar to this

Sry, this

https://github.com/clojure-emacs/cider/blob/e9324acf81391f089932c657b70031ae3c3d0824/cider.el#L863

as I'm reading my code, I'm realizing that my approach of writing Clojure forms and parsing them as quoted Elisp is probably a very very bad idea. But I promised to post the code, so I'm posting the code 🙂

(require 's)

(defmacro t-comment (&rest _) "Do nothing."
  nil)

(defun t-str (&rest xs)
  "Join XS into string."
  (apply #'s-concat
         (mapcar (lambda (s)
                   (format "%s" s))
                 xs)))

(defun t-bb-fun (form)
  "Convert quoted FORM to Babashka shell invocation."
  (t-str "bb -e " "'" form "'"))

;; Example:
;;
;;   (t-bb-fun '(assoc *input* :message "Hello!"))

(defmacro t-bb (form)
  "Convert FORM to babashka shell invocation."
  (list 't-bb-fun (list 'quote form)))

(t-comment
 ;; here's an example:

 (shell-command-to-string
  (t-bb (+ 1 2)))
 ;; => "3\n"

 (message
  (shell-command-to-string
   (t-bb (hash-map :x 1 :y 2))))
 ;; from *Messages"
 ;;
 ;; "{:y 2, :x 1}"
 )

thanks!

I already mimiced the cider function , but just parsing deps.edn

cider actually uses the same package you recommended for parsing edn 🙂

wohoo…. got it working 🙂

(defun cider--deps-parse-aliases (hash)
  (let* ((builds (when (hash-table-p hash)
                   (gethash :aliases hash)))
         (build-keys (when (hash-table-p builds)
                       (hash-table-keys builds))))
    (append build-keys '(:none))))

(defun cider--deps-get-aliases ()
  (let ((deps-edn (concat (clojure-project-dir) "deps.edn")))
    (when (file-exists-p deps-edn)
      (with-temp-buffer
        (insert-file-contents deps-edn)
        (let ((hash (car (parseedn-read '((map . identity))))))
          (cider--deps-parse-aliases  hash))))))

(defun cider-get-deps-aliases ()
  (interactive)
  (let ((options (completing-read "Select alias to run: "
                                      (cider--deps-get-aliases))))))

just in case someone cares 🙂 feedback welcome

(cider--deps-parse-aliases  hash)

(defun cider--deps-parse-aliases (hash)
  (let* ((builds (when (hash-table-p hash)
                   (gethash :aliases hash)))
         (build-keys (when (hash-table-p builds)
                       (hash-table-keys builds))))
    (append build-keys '(:none))))

(defun cider--deps-get-aliases (deps-edn)
  (cider--deps-parse-aliases
   (car (with-temp-buffer
	  (insert-file-contents deps-edn)
	  (parseedn-read '((map . identity)))))))

(defun cider-jack-in-with-an-alias-from-deps ()
  (interactive)
  (if-let* ((deps-edn (concat (clojure-project-dir) "deps.edn"))
	    (_ (file-exists-p deps-edn)))
      (let* ((my-alias
	      (completing-read "Select alias to run: " (cider--deps-get-aliases deps-edn)))
	     (cider-clojure-cli-aliases
	      (concat
	       cider-clojure-cli-aliases ":" my-alias)))
	(call-interactively #'cider-jack-in-clj))
    (user-error "no deps.edn file in project")))

I made a version using dash pattern matching

(defun cider--deps-parse-aliases (edn)
  (-when-let*
      (((m) edn)
       ((&hash :aliases aliases) m))
    (append (hash-table-keys aliases) '(:none))))

(defun cider--deps-get-aliases (deps-edn)
  (cider--deps-parse-aliases
   (with-temp-buffer
     (insert-file-contents deps-edn)
     (parseedn-read '((map . identity))))))

Nice! Looks really clean!

Will try this evening to append the result to the jack-in command

The plan is to check the preferred-build tool var, to either parse the project.clj profiles or deps.edn aliases. Check if there’s anything that overrides the default repl command and then do the jack in

But first trying to get the happy path working 😅

As my emacs lisp skills are lacking

sounds like you can use cider-project-type

Cool! Still haven’t explored the cider code enough 😅

Setting this: https://github.com/lukaszkorecki/command-center/blob/master/settings/lk/navigation.el#L32-L38 made it workable for me - find-file works with in a sub-project and C-c p p shows a project selector so I can jump between different codebases within a single repo

That’s surprising that projectile is discovering the sub-projects first. Do you have .git directories in each of the subprojects or something? One thing you can do is put a .projectile file in the directory where you want projectile to consider the project.

yes, I don't get the link between the doc I read and the behavior I end up with. Maybe a behavior of setup layers I use: doom + lsp clojure... In anycase, the .projectile solution seems to work. thx @U01ERKW6F18. I keep your solution @U0JEFEZH6 in case the other one is not actually not working. Thanks for the help!