Is it possible to include rewrite-clj, or clear examples of methods to rewrite code?

[jwhitlark]

This is already a game changer.

I frequently use rewrite-clj to update small bits of code. It's pretty awkward at the moment. Being able to script small transformations in joyride would be incredibly useful. Is there some way to accomplish this? I'm not familiar enough with sci to tell.

The below mostly does what I want, but it's really tricky to debug. Patterns, suggestions, snippets or docs on this kind of thing would be really helpful.

(ns rewrite
  (:require ["ext://betterthantomorrow.calva$v0.repl" :refer [evaluateCode]]
            ["vscode" :as vscode]
            [joyride.core :as joyride]
            [promesa.core :as p]
            [z-joylib.editor-utils :as eu]))

(defn rewrite [code]
  (str "(clojure.string/upper-case \"" code  "\")"))

(defn main []
  (-> (p/let [editor ^js vscode/window.activeTextEditor
              _ (vscode/commands.executeCommand "calva.selectCurrentForm")
              selection (eu/current-selection)
              code (rewrite (eu/current-selection-text))
              resp (evaluateCode "clj" code)
              raw-out (.-result resp)
              out (subs raw-out 1 (dec (count raw-out)))]
        (eu/delete-range! editor selection)
        (eu/insert-text!+ out editor (.-active selection)))))


(when (= (joyride/invoked-script) joyride/*file*)
  (main))

[jwhitlark]

Note that this discussion replaces #83

[jwhitlark]

@PEZ Do you have any thoughts? This is a killer feature for me, working on large codebases, but it's been tricky, and I keep having problems with it. Not sure if there's a better way to sort this out.

[borkdude]

Not really, rewrite-clj isn't compatible with SCI currently (when running it from source)

[jwhitlark]

The example above works, but when I'm trying to do something more complicated than capitalization, and something goes wrong, I can't find the details.

It just occurred to me that evaluateCode might have more than just .-result, and that might be enough to solve my problem. I'll go look at the code, but it you have a second to point me at the right place, I'd appreciate it.

[jwhitlark]

It looks like https://github.com/BetterThanTomorrow/calva/blob/45a7ec44083ad32dd85dcca60aaca3e58fb7c023/docs/site/api.md#replevaluatecode is about the right place for me to start looks. Sorry, I know this is experimental. I really appreciate the help.

[PEZ]

I'm just happy you are figuring out loud about this @jwhitlark. We probably could make calva.evaluateCode reveal a bit more about the errors.

[jwhitlark]

Thanks!

The following is starting to approach what I'm looking for. It'll read a config file to give you options (via QuickPick) for transforms, then apply it to the current form, (with requiring-resolve, just in case). This solves my biggest problem with rewrite-clj, not wanting to process the whole file or project, just transform things ad hoc.

Longer term, I want to change the selection size, depending on what transform I select, as some things require a top-level transform, and others are just current location.

It's messy, (I've not done cljs for years), but I'm hoping to clean it up to add as an example. For now, maybe it'll help someone else, or spark an idea.

(ns rewrite
  (:require ["ext://betterthantomorrow.calva$v0.repl" :refer [evaluateCode]]
            ["vscode" :as vscode]
            [joyride.core :as joyride]
            [promesa.core :as p]
            ["fs" :as fs]
            ["path" :as path]
            [clojure.edn :as edn]
            [z-joylib.editor-utils :as eu]))

(def config-file "rewrite.edn")
#_ {:funcs ["clojure.string/lower-case"
            "clojure.string/upper-case"]}

(def oc (joyride.core/output-channel))
(defn log [x]
  (.appendLine oc (str x)))

(defn load-fns []
  (p/let [cfg-file-path (path/resolve vscode/workspace.rootPath config-file)
          funcs (-> (fs/readFileSync cfg-file-path)
                    (str)
                    (edn/read-string)
                    (:funcs))]
    funcs))

(defn rewrite [f code]
  ;;(log (str "Input: " code))
  (p/let [code (str "((requiring-resolve '" f ") \"" code  "\")")
          resp (evaluateCode "clj"
                             code
                             #js {:stdout #(log %)
                                  :stderr #(log (str "Error: " %))})
          raw-out (.-result resp)]
    ;; (log (str "=> " raw-out))
    (-> resp (p/catch (fn [e]
                        (let [error (str "Evaluation error: " e)]
                          (log error)))))
    raw-out))

(defn drop-quotes [x]
  (subs x 1 (dec (count x))))

(defn main []
  (log "Rewrite Start!")
  (-> (p/let [possible-funcs (load-fns)
              func (vscode.window.showQuickPick (clj->js possible-funcs))
              editor ^js vscode/window.activeTextEditor
              _ (vscode/commands.executeCommand "calva.selectCurrentForm")
              selection (eu/current-selection)
              raw-out (rewrite func (eu/current-selection-text))
              out (drop-quotes raw-out)]
        (eu/insert-text!+ out editor (.-active selection))
        (eu/delete-range! editor selection)))
  (log "Rewrite End!"))


(when (= (joyride/invoked-script) joyride/*file*)
  (main))