tonsky / clj-reload Goto Github PK

First thanks for the great library, I've replaced tools.namespace with it and I'm much happier.

Maybe this is outside the scope of this project, but given all the nice functionality to reload namespaces in topological order I think it would be great to have a function like clj-reload.core/reload to reload namespaces by regex (like with :only) but that works on the entire classpath and which doesn't take into account or modifies the current reload state.

This can be useful in situations where you go and re-eval libraries functions (like to add debug statements), so after you are done you can do something like (clj-reload.core/reload-all #"ring.*"), and you don't need to think what functions you changed nor restart the repl.

Having a private that is loaded from stash, such as

(defonce ^:private abc {})

results in

; Execution error (IllegalStateException) at clj-reload.util/ns-load-file (util.clj:93).
; var: clj-reload.stash/abc is not public

This seems to happen because the ^:private metadata is retained when the var is stashed.

(reload/init {:dirs ["src" "dev" "test"]})
Execution error (IllegalArgumentException) at clj-reload.core/files->namespaces$fn (core.clj:56).
Don't know how to create ISeq from: java.io.File

This works:

(reload/init {:dirs ["src"]})

java.lang.RuntimeException: Record construction syntax can only be used when read-eval == true

clj-reload provides no apparent way to override the default binding here. clojure.core/require reload-all works out of the box in these situations.

Had some legacy code whereby

(ns blah 
   (:require [foo bar blah]))  ;;accidental self-reference

clojure compiler is smart enough to silently ignore this and not load self-references in the ns form; e.g. no cycle is detected when using legacy reload-all behavior or any loading. clj-reload sees the form and (rightly, or wrongly depending preferred semantics) claims there's an effective cycle in the dependency. I opted to side with clj-reload and prune the cycle, posting issue for reference.

Hey I have large codebase at 'megacorp', that I can't share, but it failing to be loaded on initial start-up via clj-reload, but works fine with tools namespace, do you have any tips on what to post here to help you diagnose the issue, i haven't had much time to dive into it, i'll take a longer look at the weekend, but it looks like it could be an issue with clj-reload. i'm getting errors like 'foo' alias does not exist when its clearly required. I can't share code, or filenames, but I can anonymize the data if you tell me what to send.

Parallel code reloading isn't safe.

So it would seem a good idea to add a lock so that one cannot reload concurrently?

This is a plausible scenario when using clj-reload via CIDER.

We could add a lock ourselves (as we do with t.n), but having it here would seem best.

WDYT?

Cheers - V

  (require '[clj-reload.parse])

  (defn read-str [s]
    (clj-reload.parse/read-file (java.io.PushbackReader. (java.io.StringReader. s)) nil))

  (read-str "(ns broken (:require [clojure.string :as string])) ::string/foo")
  ; (err) Execution error at clj-reload.parse/read-file$fn (parse.clj:79).
  ; (err) Invalid token: ::string/foo

When given a namespace that uses an aliased keyword read-file throws an exception "Invalid token: ::string/foo".

I can see that this uses clojure.core/read (with *read-eval* set to false) which is where the exception comes from. clojure.core/read will use *ns* and the aliases of the current namespace to resolve the aliased keyword. But as the file is read with *read-eval* set to false the namespace form is not evaluated and no aliases are created, so the keyword cannot be resolved.

I'm not sure how to fix this without using another reader (like clojure.tools.reader). It could work by creating namespaces and adding aliases into them.

  (binding [*read-eval* false
            *ns* (create-ns 'hacky)]
    (alias 'string 'clojure.string)
    (read (java.io.PushbackReader. (java.io.StringReader. "::string/foo"))))

But this obviously has an impact on the current environment which might not be ideal.