Closed njj closed 7 years ago
darwin
commented
8 years ago This is still the same issue as https://github.com/binaryage/dirac/issues/43.
It still looks like something is calling cljs.reader/read and that throws. I wonder why the callstack is not complete...
btw. Looks like I forgot to enable :pseudo-names for release build this time...
darwin
commented
8 years ago There are probably many places from where cljs.reader could be called.
I'm afraid you will have to help me identify the exact call site which is causing this.
cljs.reader, which in turn throws, also use the Watch/Scope panel to see the exact data passed there, so we know what exactly is malformed.
Ninerian
commented
7 years ago I have the same error. Here are more informations:
It's called in the on-message-handler function of the dirac.lib.ws-client namespace.
The given message is the following:
{:changed-namespaces {:cursive.repl.runtime {:aliases {:reflect "clojure.reflect",
:set "clojure.set"},
:interns {:symbol-details {:arglists "([sym])"},
:field->map {:arglists "([field])"},
:class-exists? {:arglists "([fqn])"},
:constructor->map {:arglists "([constructor])"},
:parse-flags {},
:mapped-metadata {:arglists "([v])"},
:class-defs {:arglists "([fqns])"},
:method->map {:arglists "([method])"},
:ns-symbols-by-name {:arglists "([ns-name])"},
:mappings {},
:completions {:arglists "([ns])"}}},
:re-com.popover {:aliases {},
:interns {}},
:tubax.core {:aliases {},
:interns {}},
:cljs.tools.reader {:aliases {},
:interns {}},
:re-com.box {:aliases {},
:interns {}},
:reagent.core {:aliases {},
:interns {}},
:re-com.text {:aliases {},
:interns {}},
:vr-secondview.components.pano-menu {:aliases {},
:interns {}},
:devtools.formatters.state {:aliases {},
:interns {}},
:clojure.browser.repl {:aliases {},
:interns {}},
:re-frame.undo {:aliases {},
:interns {}},
:devtools.reporter {:aliases {},
:interns {}},
:vr-secondview.components.history {:aliases {},
:interns {}},
:devtools.formatters {:aliases {},
:interns {}},
:sundbry.autobahn {:aliases {},
:interns {}},
:devtools.async {:aliases {},
:interns {}},
:reagent.impl.template {:aliases {},
:interns {}},
:reagent.impl.batching {:aliases {},
:interns {}},
:cljs.core.async {:aliases {},
:interns {}},
:cljs.core.async.impl.protocols {:aliases {},
:interns {}},
:figwheel.client.file-reloading {:aliases {},
:interns {}},
:dirac.runtime.repl {:aliases {},
:interns {}},
:cljs.core.async.impl.buffers {:aliases {},
:interns {}},
:cljs-time.core {:aliases {},
:interns {}},
:re-frame.router {:aliases {},
:interns {}},
:clojure.core {:aliases {},
:interns {:doseq {:arglists "([seq-exprs & body])",
:macro "true"},
:unsigned-bit-shift-right {:arglists "([x n])"},
:neg? {:arglists "([x])"},
:expand-method-impl-cache {:arglists "([cache c f])"},
:load-one {:arglists "([lib need-ns require])"},
:load-data-readers {:arglists "([])"},
:var-set {:arglists "([x val])"},
:global-hierarchy {},
:load {:arglists "([& paths])"},
:if-not {:arglists "([test then] [test then else])",
:macro "true"},
:sequential? {:arglists "([coll])"},
:*verbose-defrecords* {},
:*print-level* {},
:shuffle {:arglists "([coll])"},
:boolean-array {:arglists "([size-or-seq] [size init-val-or-seq])"},
:find {:arglists "([map key])"},
:ams {},
:build-positional-factory {:arglists "([nom classname fields])"},
:alength {:arglists "([array])"},
:bit-xor {:arglists "([x y] [x y & more])"},
:deliver {:arglists "([promise val])"},
:when-let {:arglists "([bindings & body])",
:macro "true"},
:int-array {:arglists "([size-or-seq] [size init-val-or-seq])"},
:set? {:arglists "([x])"},
:inc' {:arglists "([x])"},
:process-annotation {:arglists "([av v])"},
:cat {:arglists "([rf])"},
:*suppress-read* {},
:flush {:arglists "([])"},
:take-while {:arglists "([pred] [pred coll])"},
:unchecked-float {:arglists "([x])"},
:pmap {:arglists "([f coll] [f coll & colls])"},
:error-mode {:arglists "([a])"},
:num {:arglists "([x])"},
:reduced? {:arglists "([x])"},
:disj! {:arglists "([set] [set key] [set key & ks])"},
:float? {:arglists "([n])"},
:aset-float {:arglists "([array idx val] [array idx idx2 & idxv])"},
:bean {:arglists "([x])"},
:deftype {:arglists "([name [& fields] & opts+specs])",
:macro "true"},
:booleans {:arglists "([xs])"},
:normalize-slurp-opts {:arglists "([opts])"},
:ns-unalias {:arglists "([ns sym])"},
:re-pattern {:arglists "([s])"},
:min {:arglists "([x] [x y] [x y & more])"},
:pop! {:arglists "([coll])"},
:chunk-append {:arglists "([b x])"},
:nary-inline {:arglists "([op] [op unchecked-op])"},
:prn-str {:arglists "([& xs])"},
:with-precision {:arglists "([precision & exprs])",
:macro "true"},
:super-chain {:arglists "([c])"},
:format {:arglists "([fmt & args])"},
:reversible? {:arglists "([coll])"},
:shutdown-agents {:arglists "([])"},
:vary-meta {:arglists "([obj f & args])"},
:<= {:arglists "([x] [x y] [x y & more])"},
:alter {:arglists "([ref fun & args])"},
:-' {:arglists "([x] [x y] [x y & more])"},
:if-some {:arglists "([bindings then] [bindings then else & oldform])",
:macro "true"},
:conj! {:arglists "([] [coll] [coll x])"},
:repeatedly {:arglists "([f] [n f])"},
:zipmap {:arglists "([keys vals])"},
:alter-var-root {:arglists "([v f & args])"},
:biginteger {:arglists "([x])"},
:descriptor {:arglists "([c])"},
:remove {:arglists "([pred] [pred coll])"},
:* {:arglists "([] [x] [x y] [x y & more])"},
:-> {:arglists "([x & forms])",
:macro "true"},
:defstruct {:arglists "([name & keys])",
:macro "true"},
:protocol? {:arglists "([maybe-p])"},
:*err* {},
:assert-same-protocol {:arglists "([protocol-var method-syms])"},
:get {:arglists "([map key] [map key not-found])"},
:doto {:arglists "([x & forms])",
:macro "true"},
:identity {:arglists "([x])"},
:into {:arglists "([to from] [to xform from])"},
:areduce {:arglists "([a idx ret init expr])",
:macro "true"},
:long {:arglists "([x])"},
:double {:arglists "([x])"},
:volatile? {:arglists "([x])"},
:conj {:arglists "([coll x] [coll x & xs])"},
:transduce {:arglists "([xform f coll] [xform f init coll])"},
:bound? {:arglists "([& vars])"},
:lazy-seq {:arglists "([& body])",
:macro "true"},
:*print-length* {},
:*file* {},
:compare-and-set! {:arglists "([atom oldval newval])"},
:*use-context-classloader* {},
:await1 {:arglists "([a])"},
:let {:arglists "([bindings & body])",
:macro "true"},
:parse-opts+specs {:arglists "([opts+specs])"},
:ref-set {:arglists "([ref val])"},
:pop-thread-bindings {:arglists "([])"},
:interleave {:arglists "([] [c1] [c1 c2] [c1 c2 & colls])"},
:print-map {:arglists "([m print-one w])"},
:printf {:arglists "([fmt & args])"},
:map? {:arglists "([x])"},
:cycle {:arglists "([coll])"},
:fn {:arglists "([& sigs])",
:macro "true"},
:seque {:arglists "([s] [n-or-q s])"},
:empty? {:arglists "([coll])"},
:short {:arglists "([x])"},
:definterface {:arglists "([name & sigs])",
:macro "true"},
:pref {:arglists "([] [a] [a b])"},
:filterv {:arglists "([pred coll])"},
:hash {:arglists "([x])"},
:definline {:arglists "([name & decl])",
:macro "true"},
:nfirst {:arglists "([x])"},
:meta {:arglists "([obj])"},
:find-protocol-impl {:arglists "([protocol x])"},
:emit-extend-protocol {:arglists "([p specs])"},
:bit-and-not {:arglists "([x y] [x y & more])"},
:*default-data-reader-fn* {},
:var? {:arglists "([v])"},
:method-sig {:arglists "([meth])"},
:unchecked-add-int {:arglists "([x y])"},
:unquote-splicing {},
:emit-method-builder {:arglists "([on-interface method on-method arglists])"},
:hash-ordered-coll {:arglists "([coll])"},
:deref-as-map {:arglists "([o])"},
:future {:arglists "([& body])",
:macro "true"},
:reset-meta! {:arglists "([iref metadata-map])"},
:shift-mask {:arglists "([shift mask x])"},
:chunk-rest {:arglists "([s])"},
:pcalls {:arglists "([& fns])"},
:*allow-unresolved-vars* {},
:ns-resolve {:arglists "([ns sym] [ns env sym])"},
:remove-all-methods {:arglists "([multifn])"},
:most-specific {:arglists "([rtypes])"},
:as-> {:arglists "([expr name & forms])",
:macro "true"},
:aset-boolean {:arglists "([array idx val] [array idx idx2 & idxv])"},
:trampoline {:arglists "([f] [f & args])"},
:fits-table? {:arglists "([ints])"},
:when-not {:arglists "([test & body])",
:macro "true"},
:*1 {},
:vec {:arglists "([coll])"},
:*print-meta* {},
:quot {:arglists "([num div])"},
:ns-aliases {:arglists "([ns])"},
:read {:arglists "([] [stream] [stream eof-error? eof-value] [stream eof-error? eof-value recursive?] [opts stream])"},
:unchecked-double {:arglists "([x])"},
:key {:arglists "([e])"},
:longs {:arglists "([xs])"},
:not= {:arglists "([x] [x y] [x y & more])"},
:string? {:arglists "([x])"},
:emit-defrecord {:arglists "([tagname cname fields interfaces methods opts])"},
:aset-double {:arglists "([array idx val] [array idx idx2 & idxv])"},
:overload-name {:arglists "([mname pclasses])"},
:unchecked-multiply-int {:arglists "([x y])"},
:unchecked-int {:arglists "([x])"},
:set-error-handler! {:arglists "([a handler-fn])"},
:keyword? {:arglists "([x])"},
:force {:arglists "([x])"},
:bound-fn* {:arglists "([f])"},
:namespace-munge {:arglists "([ns])"},
:group-by {:arglists "([f coll])"},
:prn {:arglists "([& more])"},
:extend {:arglists "([atype & proto+mmaps])"},
:when {:arglists "([test & body])",
:macro "true"},
:int {:arglists "([x])"},
:print-meta {:arglists "([o w])"},
:map-entry? {:arglists "([x])"},
:ns-refers {:arglists "([ns])"},
:rand {:arglists "([] [n])"},
:second {:arglists "([x])"},
:vector-of {:arglists "([t] [t & elements])"},
:hash-combine {:arglists "([x y])"},
:> {:arglists "([x] [x y] [x y & more])"},
:replace {:arglists "([smap] [smap coll])"},
:associative? {:arglists "([coll])"},
:defn {:arglists "([name doc-string? attr-map? [params*] prepost-map? body] [name doc-string? attr-map? ([params*] prepost-map? body) + attr-map?])",
:macro "true"},
:ref {:arglists "([x] [x & options])"},
:bigint {:arglists "([x])"},
:spread {:arglists "([arglist])"},
:extends? {:arglists "([protocol atype])"},
:promise {:arglists "([])"},
:aset-char {:arglists "([array idx val] [array idx idx2 & idxv])"},
:rseq {:arglists "([rev])"},
:load-all {:arglists "([lib need-ns require])"},
:construct-proxy {:arglists "([c & ctor-args])"},
:agent-errors {:arglists "([a])",
:deprecated "\"1.2\""},
:*compile-files* {},
:>0? {:arglists "([n])"},
:unchecked-multiply {:arglists "([x y])"},
:print-tagged-object {:arglists "([o rep w])"},
:default-data-readers {},
:some->> {:arglists "([expr & forms])",
:macro "true"},
:->VecSeq {:arglists "([am vec anode i offset])"},
:even? {:arglists "([n])"},
:unchecked-dec {:arglists "([x])"},
:tagged-literal? {:arglists "([value])"},
:double-array {:arglists "([size-or-seq] [size init-val-or-seq])"},
:in-ns {:arglists "([name])"},
:create-ns {:arglists "([sym])"},
:re-matcher {:arglists "([re s])"},
:*loading-verbosely* {},
:amap {:arglists "([a idx ret expr])",
:macro "true"},
:pop {:arglists "([coll])"},
:use {:arglists "([& args])"},
:print-object {:arglists "([o w])"},
:unquote {},
:declare {:arglists "([& names])",
:macro "true"},
:*math-context* {},
:float {:arglists "([x])"},
:pr-str {:arglists "([& xs])"},
:concat {:arglists "([] [x] [x y] [x y & zs])"},
:aset-short {:arglists "([array idx val] [array idx idx2 & idxv])"},
:set-agent-send-off-executor! {:arglists "([executor])"},
:ns {:arglists "([name docstring? attr-map? references*])",
:macro "true"},
:mk-am {:arglists "([t])",
:macro "true"},
:symbol {:arglists "([name] [ns name])"},
:to-array-2d {:arglists "([coll])"},
:valid-java-method-name {:arglists "([s])"},
:mod {:arglists "([num div])"},
:reset! {:arglists "([atom newval])"},
:name {:arglists "([x])"},
:ffirst {:arglists "([x])"},
:emit-protocol {:arglists "([name opts+sigs])"},
:sorted-set {:arglists "([& keys])"},
:emit-hinted-impl {:arglists "([c [p fs]])"},
:counted? {:arglists "([coll])"},
:byte-array {:arglists "([size-or-seq] [size init-val-or-seq])"},
:dissoc! {:arglists "([map key] [map key & ks])"},
:reductions {:arglists "([f coll] [f init coll])"},
:aset-byte {:arglists "([array idx val] [array idx idx2 & idxv])"},
:ref-history-count {:arglists "([ref])"},
:- {:arglists "([x] [x y] [x y & more])"},
:assoc! {:arglists "([coll key val] [coll key val & kvs])"},
:hash-set {:arglists "([] [& keys])"},
:reduce-kv {:arglists "([f init coll])"},
:or {:arglists "([] [x] [x & next])",
:macro "true"},
:cast {:arglists "([c x])"},
:EMPTY-NODE {},
:time {:arglists "([expr])",
:macro "true"},
:memoize {:arglists "([f])"},
:alter-meta! {:arglists "([iref f & args])"},
:future? {:arglists "([x])"},
:zero? {:arglists "([x])"},
:add-annotations {:arglists "([visitor m] [visitor m i])"},
:tagged-literal {:arglists "([tag form])"},
:println {:arglists "([& more])"},
:assert-args {:arglists "([& pairs])",
:macro "true"},
:extend-type {:arglists "([t & specs])",
:macro "true"},
:macroexpand-1 {:arglists "([form])"},
:assoc-in {:arglists "([m [k & ks] v])"},
:char-name-string {},
:bit-test {:arglists "([x n])"},
:defmethod {:arglists "([multifn dispatch-val & fn-tail])",
:macro "true"},
:memfn {:arglists "([name & args])",
:macro "true"},
:struct-map {:arglists "([s & inits])"},
:drop {:arglists "([n] [n coll])"},
:parse-impls {:arglists "([specs])"},
:*data-readers* {},
:load-libs {:arglists "([& args])"},
:nth {:arglists "([coll index] [coll index not-found])"},
:nil? {:arglists "([x])"},
:sorted? {:arglists "([coll])"},
:extend-protocol {:arglists "([p & specs])",
:macro "true"},
:split-at {:arglists "([n coll])"},
:*e {},
:validate-generate-class-options {:arglists "([{:keys [methods]}])"},
:load-reader {:arglists "([rdr])"},
:require {:arglists "([& args])"},
:unchecked-dec-int {:arglists "([x])"},
:persistent! {:arglists "([coll])"},
:nnext {:arglists "([x])"},
:not-every? {:arglists "([pred coll])"},
:class? {:arglists "([x])"},
:add-watch {:arglists "([reference key fn])"},
:rem {:arglists "([num div])"},
:agent-error {:arglists "([a])"},
:some {:arglists "([pred coll])"},
:future-cancelled? {:arglists "([f])"},
:instance? {:arglists "([c x])"},
:with-open {:arglists "([bindings & body])",
:macro "true"},
:mix-collection-hash {:arglists "([hash-basis count])"},
:re-find {:arglists "([m] [re s])"},
:run! {:arglists "([proc coll])"},
:val {:arglists "([e])"},
:defonce {:arglists "([name expr])",
:macro "true"},
:unchecked-add {:arglists "([x y])"},
:print-sequential {:arglists "([begin print-one sep end sequence w])"},
:loaded-libs {:arglists "([])"},
:->Vec {:arglists "([am cnt shift root tail _meta])"},
:filter-methods {:arglists "([c invalid-method?])"},
:not {:arglists "([x])"},
:with-meta {:arglists "([obj m])"},
:unreduced {:arglists "([x])"},
:the-ns {:arglists "([x])"},
:record? {:arglists "([x])"},
:type {:arglists "([x])"},
:identical? {:arglists "([x y])"},
:random-sample {:arglists "([prob] [prob coll])"},
:cond-> {:arglists "([expr & clauses])",
:macro "true"},
:dotimes {:arglists "([bindings & body])",
:macro "true"},
:select-keys {:arglists "([map keyseq])"},
:bit-and {:arglists "([x y] [x y & more])"},
:update {:arglists "([m k f] [m k f x] [m k f x y] [m k f x y z] [m k f x y z & more])"},
:group-by-sig {:arglists "([coll])"},
:list* {:arglists "([args] [a args] [a b args] [a b c args] [a b c d & more])"},
:reify {:arglists "([& opts+specs])",
:macro "true"},
:update-in {:arglists "([m [k & ks] f & args])"},
:prefer-method {:arglists "([multifn dispatch-val-x dispatch-val-y])"},
:aset-int {:arglists "([array idx val] [array idx idx2 & idxv])"},
:*clojure-version* {},
:ensure-reduced {:arglists "([x])"},
:*' {:arglists "([] [x] [x y] [x y & more])"},
:set-validator! {:arglists "([iref validator-fn])"},
:maybe-destructured {:arglists "([params body])"},
:maybe-min-hash {:arglists "([hashes])"},
:max-switch-table-size {},
:defprotocol {:arglists "([name & opts+sigs])",
:macro "true"},
:the-class {:arglists "([x])"},
:swap! {:arglists "([atom f] [atom f x] [atom f x y] [atom f x y & args])"},
:vals {:arglists "([map])"},
:unchecked-divide-int {:arglists "([x y])"},
:ns-name {:arglists "([ns])"},
:is-annotation? {:arglists "([c])"},
:max-key {:arglists "([k x] [k x y] [k x y & more])"},
:*unchecked-math* {},
:defn- {:arglists "([name & decls])",
:macro "true"},
:*out* {},
:file-seq {:arglists "([dir])"},
:agent {:arglists "([state & options])"},
:ns-map {:arglists "([ns])"},
:remove-method {:arglists "([multifn dispatch-val])"},
:*in* {},
:load-lib {:arglists "([prefix lib & options])"},
:print-ctor {:arglists "([o print-args w])"},
:letfn {:arglists "([fnspecs & body])",
:macro "true"},
:volatile! {:arglists "([val])"},
:/ {:arglists "([x] [x y] [x y & more])"},
:read-line {:arglists "([])"},
:binding-conveyor-fn {:arglists "([f])"},
:reader-conditional? {:arglists "([value])"},
:bit-or {:arglists "([x y] [x y & more])"},
:clear-agent-errors {:arglists "([a])",
:deprecated "\"1.2\""},
:vector {:arglists "([] [a] [a b] [a b c] [a b c d] [a b c d e] [a b c d e f] [a b c d e f & args])"},
:unchecked-subtract {:arglists "([x y])"},
:*warn-on-reflection* {},
:sorted-set-by {:arglists "([comparator & keys])"},
:sync {:arglists "([flags-ignored-for-now & body])",
:macro "true"},
:assert {:arglists "([x] [x message])",
:macro "true"},
:*compile-path* {},
:true? {:arglists "([x])"},
:array {:arglists "([& items])"},
:release-pending-sends {:arglists "([])"},
:print {:arglists "([& more])"},
:empty {:arglists "([coll])"},
:add-classpath {:arglists "([url])",
:deprecated "\"1.1\""},
:bit-flip {:arglists "([x n])"},
:long-array {:arglists "([size-or-seq] [size init-val-or-seq])"},
:filter-key {:arglists "([keyfn pred amap])"},
:descendants {:arglists "([tag] [h tag])"},
:find-field {:arglists "([c f])"},
:merge {:arglists "([& maps])"},
:accessor {:arglists "([s key])"},
:proxy-super {:arglists "([meth & args])",
:macro "true"},
:>= {:arglists "([x] [x y] [x y & more])"},
:drop-last {:arglists "([s] [n s])"},
:not-empty {:arglists "([coll])"},
:root-directory {:arglists "([lib])"},
:distinct {:arglists "([] [coll])"},
:partition {:arglists "([n coll] [n step coll] [n step pad coll])"},
:data-reader-urls {:arglists "([])"},
:loop {:arglists "([bindings & body])",
:macro "true"},
:special-symbol? {:arglists "([s])"},
:prep-hashes {:arglists "([expr-sym default tests thens])"},
:subseq {:arglists "([sc test key] [sc start-test start-key end-test end-key])"},
:error-handler {:arglists "([a])"},
:ancestors {:arglists "([tag] [h tag])"},
:gensym {:arglists "([] [prefix-string])"},
:cond {:arglists "([& clauses])",
:macro "true"},
:check-valid-options {:arglists "([options & valid-keys])"},
:ratio? {:arglists "([n])"},
:delay? {:arglists "([x])"},
:intern {:arglists "([ns name] [ns name val])"},
:print-simple {:arglists "([o w])"},
:flatten {:arglists "([x])"},
:doubles {:arglists "([xs])"},
:integer? {:arglists "([n])"},
:mapv {:arglists "([f coll] [f c1 c2] [f c1 c2 c3] [f c1 c2 c3 & colls])"},
:partition-all {:arglists "([n] [n coll] [n step coll])"},
:partition-by {:arglists "([f] [f coll])"},
:numerator {:arglists "([r])"},
:object-array {:arglists "([size-or-seq])"},
:with-out-str {:arglists "([& body])",
:macro "true"},
:condp {:arglists "([pred expr & clauses])",
:macro "true"},
:derive {:arglists "([tag parent] [h tag parent])"},
:load-string {:arglists "([s])"},
:chunked-seq? {:arglists "([s])"},
:find-keyword {:arglists "([name] [ns name])"},
:replicate {:arglists "([n x])",
:deprecated "\"1.3\""},
:min-key {:arglists "([k x] [k x y] [k x y & more])"},
:reduced {:arglists "([x])"},
:char-escape-string {},
:re-matches {:arglists "([re s])"},
:array-map {:arglists "([] [& keyvals])"},
:unchecked-byte {:arglists "([x])"},
:reduce1 {:arglists "([f coll] [f val coll])"},
:with-local-vars {:arglists "([name-vals-vec & body])",
:macro "true"},
:ns-imports {:arglists "([ns])"},
:send-off {:arglists "([a f & args])"},
:defmacro {:arglists "([name doc-string? attr-map? [params*] body] [name doc-string? attr-map? ([params*] body) + attr-map?])",
:macro "true"},
:with-in-str {:arglists "([s & body])",
:macro "true"},
:remove-watch {:arglists "([reference key])"},
:ex-info {:arglists "([msg map] [msg map cause])"},
:ifn? {:arglists "([x])"},
:some-> {:arglists "([expr & forms])",
:macro "true"},
:asm-type {:arglists "([c])"},
:proxy-name {:arglists "([super interfaces])"},
:ns-interns {:arglists "([ns])"},
:all-ns {:arglists "([])"},
:find-protocol-method {:arglists "([protocol methodk x])"},
:subvec {:arglists "([v start] [v start end])"},
:for {:arglists "([seq-exprs body-expr])",
:macro "true"},
:binding {:arglists "([bindings & body])",
:macro "true"},
:partial {:arglists "([f] [f arg1] [f arg1 arg2] [f arg1 arg2 arg3] [f arg1 arg2 arg3 & more])"},
:print-throwable {:arglists "([o w])"},
:*3 {},
:validate-fields {:arglists "([fields name])"},
:alias {:arglists "([alias namespace-sym])"},
:frequencies {:arglists "([coll])"},
:read-string {:arglists "([s] [opts s])"},
:proxy {:arglists "([class-and-interfaces args & fs])",
:macro "true"},
:rsubseq {:arglists "([sc test key] [sc start-test start-key end-test end-key])"},
:inc {:arglists "([x])"},
:get-method {:arglists "([multifn dispatch-val])"},
:with-redefs {:arglists "([bindings & body])",
:macro "true"},
:bit-clear {:arglists "([x n])"},
:filter {:arglists "([pred] [pred coll])"},
:every-pred {:arglists "([p] [p1 p2] [p1 p2 p3] [p1 p2 p3 & ps])"},
:keys {:arglists "([map])"},
:rationalize {:arglists "([num])"},
:load-file {:arglists "([name])"},
:distinct? {:arglists "([x] [x y] [x y & more])"},
:max-mask-bits {},
:libspec? {:arglists "([x])"},
:prep-ints {:arglists "([tests thens])"},
:extenders {:arglists "([protocol])"},
:unchecked-short {:arglists "([x])"},
:methods {:arglists "([multifn])"},
:odd? {:arglists "([n])"},
:->ArrayChunk {:arglists "([am arr off end])"},
:float-array {:arglists "([size-or-seq] [size init-val-or-seq])"},
:ctor-sigs {:arglists "([super])"},
:chars {:arglists "([xs])"},
:str {:arglists "([] [x] [x & ys])"},
:next {:arglists "([coll])"},
:hash-map {:arglists "([] [& keyvals])"},
:if-let {:arglists "([bindings then] [bindings then else & oldform])",
:macro "true"},
:underive {:arglists "([tag parent] [h tag parent])"},
:ref-max-history {:arglists "([ref] [ref n])"},
:locking {:arglists "([x & body])",
:macro "true"},
:list {:arglists "([& items])"},
:+ {:arglists "([] [x] [x y] [x y & more])"},
:def-aset {:arglists "([name method coerce])",
:macro "true"},
:split-with {:arglists "([pred coll])"},
:aset {:arglists "([array idx val] [array idx idx2 & idxv])"},
:->VecNode {:arglists "([edit arr])"},
:keyword {:arglists "([name] [ns name])"},
:*ns* {},
:destructure {:arglists "([bindings])"},
:*assert* {},
:defmulti {:arglists "([name docstring? attr-map? dispatch-fn & options])",
:macro "true"},
:non-private-methods {:arglists "([c])"},
:bit-not {:arglists "([x])"},
:io! {:arglists "([& body])",
:macro "true"},
:generate-interface {:arglists "([{:keys [name extends methods]}])"},
:xml-seq {:arglists "([root])"},
:case-map {:arglists "([case-f test-f tests thens])"},
:byte {:arglists "([x])"},
:max {:arglists "([x] [x y] [x y & more])"},
:== {:arglists "([x] [x y] [x y & more])"},
:Throwable->map {:arglists "([o])"},
:false? {:arglists "([x])"},
:*print-readably* {},
:ints {:arglists "([xs])"},
:case {:arglists "([e & clauses])",
:macro "true"},
:class {:arglists "([x])"},
:some-fn {:arglists "([p] [p1 p2] [p1 p2 p3] [p1 p2 p3 & ps])"},
:*flush-on-newline* {},
:to-array {:arglists "([coll])"},
:bigdec {:arglists "([x])"},
:list? {:arglists "([x])"},
:add-doc-and-meta {:arglists "([name docstring meta])",
:macro "true"},
:interpose {:arglists "([sep] [sep coll])"},
:deref {:arglists "([ref] [ref timeout-ms timeout-val])"},
:emit-impl {:arglists "([[p fs]])"},
:*pending-paths* {},
:assoc {:arglists "([map key val] [map key val & kvs])"},
:*agent* {},
:lazy-cat {:arglists "([& colls])",
:macro "true"},
:comment {:arglists "([& body])",
:macro "true"},
:parents {:arglists "([tag] [h tag])"},
:count {:arglists "([coll])"},
:root-resource {:arglists "([lib])"},
:*loaded-libs* {},
:supers {:arglists "([class])"},
:generate-proxy {:arglists "([super interfaces])"},
:*fn-loader* {},
:sorted-map-by {:arglists "([comparator & keyvals])"},
:apply {:arglists "([f args] [f x args] [f x y args] [f x y z args] [f a b c d & args])"},
:complement {:arglists "([f])"},
:*compiler-options* {},
:*print-dup* {},
:defrecord {:arglists "([name [& fields] & opts+specs])",
:macro "true"},
:with-redefs-fn {:arglists "([binding-map func])"},
:sequence {:arglists "([coll] [xform coll] [xform coll & colls])"},
:constantly {:arglists "([x])"},
:get-proxy-class {:arglists "([& bases])"},
:system-newline {},
:rational? {:arglists "([n])"},
:transient {:arglists "([coll])"},
:clojure-version {:arglists "([])"},
:merge-hash-collisions {:arglists "([expr-sym default tests thens])"},
:chunk-cons {:arglists "([chunk rest])"},
:comparator {:arglists "([pred])"},
:sorted-map {:arglists "([& keyvals])"},
:send {:arglists "([a f & args])"},
:drop-while {:arglists "([pred] [pred coll])"},
:proxy-call-with-super {:arglists "([call this meth])"},
:realized? {:arglists "([x])"},
:char-array {:arglists "([size-or-seq] [size init-val-or-seq])"},
:resolve {:arglists "([sym] [env sym])"},
:compare {:arglists "([x y])"},
:nthnext {:arglists "([coll n])"},
:and {:arglists "([] [x] [x & next])",
:macro "true"},
:create-struct {:arglists "([& keys])"},
:preserving-reduced {:arglists "([rf])"},
:get-validator {:arglists "([iref])"},
:number? {:arglists "([x])"},
:await-for {:arglists "([timeout-ms & agents])"},
:chunk-next {:arglists "([s])"},
:print-str {:arglists "([& xs])"},
:not-any? {:arglists "([pred coll])"},
:into-array {:arglists "([aseq] [type aseq])"},
:make-array {:arglists "([type len] [type dim & more-dims])"},
:shorts {:arglists "([xs])"},
:completing {:arglists "([f] [f cf])"},
:update-proxy {:arglists "([proxy mappings])"},
:unchecked-negate-int {:arglists "([x])"},
:hash-unordered-coll {:arglists "([coll])"},
:repeat {:arglists "([x] [n x])"},
:unchecked-inc {:arglists "([x])"},
:coll? {:arglists "([x])"},
:get-in {:arglists "([m ks] [m ks not-found])"},
:fnext {:arglists "([x])"},
:denominator {:arglists "([r])"},
:bytes {:arglists "([xs])"},
:refer-clojure {:arglists "([& filters])",
:macro "true"},
:escape-class-name {:arglists "([c])"},
:init-proxy {:arglists "([proxy mappings])"},
:chunk-buffer {:arglists "([capacity])"},
:symbol? {:arglists "([x])"},
:when-some {:arglists "([bindings & body])",
:macro "true"},
:unchecked-char {:arglists "([x])"},
:>1? {:arglists "([n])"},
:->> {:arglists "([x & forms])",
:macro "true"},
:future-cancel {:arglists "([f])"},
:var-get {:arglists "([x])"},
:commute {:arglists "([ref fun & args])"},
:when-first {:arglists "([bindings & body])",
:macro "true"},
:find-ns {:arglists "([sym])"},
:get-thread-bindings {:arglists "([])"},
:into1 {:arglists "([to from])"},
:contains? {:arglists "([coll key])"},
:every? {:arglists "([pred coll])"},
:proxy-mappings {:arglists "([proxy])"},
:keep-indexed {:arglists "([f] [f coll])"},
:cond->> {:arglists "([expr & clauses])",
:macro "true"},
:subs {:arglists "([s start] [s start end])"},
:ref-min-history {:arglists "([ref] [ref n])"},
:primitives-classnames {},
:+' {:arglists "([] [x] [x y] [x y & more])"},
:decimal? {:arglists "([n])"},
:prependss {:arglists "([x coll])"},
:restart-agent {:arglists "([a new-state & options])"},
:sort-by {:arglists "([keyfn coll] [keyfn comp coll])"},
:is-runtime-annotation? {:arglists "([c])"},
:macroexpand {:arglists "([form])"},
:ensure {:arglists "([ref])"},
:imap-cons {:arglists "([this o])"},
:chunk-first {:arglists "([s])"},
:add-annotation {:arglists "([av name v])"},
:load-data-reader-file {:arglists "([mappings url])"},
:eduction {:arglists "([xform* coll])"},
:tree-seq {:arglists "([branch? children root])"},
:unchecked-remainder-int {:arglists "([x y])"},
:seq {:arglists "([coll])"},
:reduce {:arglists "([f coll] [f val coll])"},
:line-seq {:arglists "([rdr])"},
:unchecked-subtract-int {:arglists "([x y])"},
:take-nth {:arglists "([n] [n coll])"},
:first {:arglists "([coll])"},
:re-groups {:arglists "([m])"},
:seq? {:arglists "([x])"},
:dec' {:arglists "([x])"},
:ns-unmap {:arglists "([ns sym])"},
:println-str {:arglists "([& xs])"},
:with-bindings* {:arglists "([binding-map f & args])"},
:iterator-seq {:arglists "([iter])"},
:sigs {},
:set {:arglists "([coll])"},
:take-last {:arglists "([n coll])"},
:bit-set {:arglists "([x n])"},
:reader-conditional {:arglists "([form splicing?])"},
:gen-class {:arglists "([& options])",
:macro "true"},
:while {:arglists "([test & body])",
:macro "true"},
:->Eduction {:arglists "([xform coll])"},
:throw-if {:arglists "([pred fmt & args])"},
:butlast {:arglists "([coll])"},
:satisfies? {:arglists "([protocol x])"},
:pr-on {:arglists "([x w])"},
:dissoc {:arglists "([map] [map key] [map key & ks])"},
:atom {:arglists "([x] [x & options])"},
:import {:arglists "([& import-symbols-or-lists])",
:macro "true"},
:bit-shift-right {:arglists "([x n])"},
:print-method {},
:peek {:arglists "([coll])"},
:aget {:arglists "([array idx] [array idx & idxs])"},
:pvalues {:arglists "([& exprs])",
:macro "true"},
:bound-fn {:arglists "([& fntail])",
:macro "true"},
:check-cyclic-dependency {:arglists "([path])"},
:iterate {:arglists "([f x])"},
:slurp {:arglists "([f & opts])"},
:newline {:arglists "([])"},
:short-array {:arglists "([size-or-seq] [size init-val-or-seq])"},
:deref-future {:arglists "([fut] [fut timeout-ms timeout-val])"},
:fn? {:arglists "([x])"},
:doall {:arglists "([coll] [n coll])"},
:prefers {:arglists "([multifn])"},
:enumeration-seq {:arglists "([e])"},
:dedupe {:arglists "([] [coll])"},
:bit-shift-left {:arglists "([x n])"},
:find-var {:arglists "([sym])"},
:rand-int {:arglists "([n])"},
:aclone {:arglists "([array])"},
:vreset! {:arglists "([vol newval])"},
:chunk {:arglists "([b])"},
:dec {:arglists "([x])"},
:future-call {:arglists "([f])"},
:resultset-seq {:arglists "([rs])"},
:struct {:arglists "([s & vals])"},
:mk-bound-fn {:arglists "([sc test key])"},
:vswap! {:arglists "([vol f & args])",
:macro "true"},
:last {:arglists "([coll])"},
:pr {:arglists "([] [x] [x & more])"},
:namespace {:arglists "([x])"},
:push-thread-bindings {:arglists "([bindings])"},
:bases {:arglists "([c])"},
:= {:arglists "([x] [x y] [x y & more])"},
:dosync {:arglists "([& exprs])",
:macro "true"},
:take {:arglists "([n] [n coll])"},
:remove-ns {:arglists "([sym])"},
:vector? {:arglists "([x])"},
:thread-bound? {:arglists "([& vars])"},
:send-via {:arglists "([executor a f & args])"},
:boolean {:arglists "([x])"},
:compile {:arglists "([lib])"},
:isa? {:arglists "([child parent] [h child parent])"},
:.. {:arglists "([x form] [x form & more])",
:macro "true"},
:munge {:arglists "([s])"},
:delay {:arglists "([& body])",
:macro "true"},
:protected-final-methods {:arglists "([c])"},
:set-error-mode! {:arglists "([a mode-keyword])"},
:re-seq {:arglists "([re s])"},
:char? {:arglists "([x])"},
:make-hierarchy {:arglists "([])"},
:data-reader-var {:arglists "([sym])"},
:map {:arglists "([f] [f coll] [f c1 c2] [f c1 c2 c3] [f c1 c2 c3 & colls])"},
:juxt {:arglists "([f] [f g] [f g h] [f g h & fs])"},
:print-initialized {},
:setup-reference {:arglists "([r options])"},
:ns-publics {:arglists "([ns])"},
:< {:arglists "([x] [x y] [x y & more])"},
:*source-path* {},
:with-loading-context {:arglists "([& body])",
:macro "true"},
:test {:arglists "([v])"},
:rest {:arglists "([coll])"},
:ex-data {:arglists "([ex])"},
:emit-deftype* {:arglists "([tagname cname fields interfaces methods opts])"},
:sort {:arglists "([coll] [comp coll])"},
:generate-class {:arglists "([options-map])"},
:-cache-protocol-fn {:arglists "([pf x c interf])"},
:unchecked-inc-int {:arglists "([x])"},
:map-indexed {:arglists "([f] [f coll])"},
:with-bindings {:arglists "([binding-map & body])",
:macro "true"},
:rand-nth {:arglists "([coll])"},
:comp {:arglists "([] [f] [f g] [f g & fs])"},
:await {:arglists "([& agents])"},
:spit {:arglists "([f content & options])"},
:future-done? {:arglists "([f])"},
:set-agent-send-executor! {:arglists "([executor])"},
:keep {:arglists "([f] [f coll])"},
:char {:arglists "([x])"},
:mapcat {:arglists "([f] [f & colls])"},
:unchecked-long {:arglists "([x])"},
:emit-extend-type {:arglists "([c specs])"},
:aset-long {:arglists "([array idx val] [array idx idx2 & idxv])"},
:some? {:arglists "([x])"},
:unchecked-negate {:arglists "([x])"},
:get-super-and-interfaces {:arglists "([bases])"},
:parse-opts {:arglists "([s])"},
:gen-interface {:arglists "([& options])",
:macro "true"},
:reverse {:arglists "([coll])"},
:*command-line-args* {},
:prim->class {},
:range {:arglists "([] [end] [start end] [start end step])"},
:cons {:arglists "([x seq])"},
:refer {:arglists "([ns-sym & filters])"},
:print-dup {},
:-reset-methods {:arglists "([protocol])"},
:floats {:arglists "([xs])"},
:pos? {:arglists "([x])"},
:fnil {:arglists "([f x] [f x y] [f x y z])"},
:merge-with {:arglists "([f & maps])"},
:nthrest {:arglists "([coll n])"},
:*read-eval* {},
:dorun {:arglists "([coll] [n coll])"},
:implements? {:arglists "([protocol atype])"},
:assert-valid-fdecl {:arglists "([fdecl])"},
:disj {:arglists "([set] [set key] [set key & ks])"},
:*2 {},
:eval {:arglists "([form])"}}},
:vr-secondview.utils.path-gen {:aliases {},
:interns {}},
:tubax.helpers {:aliases {},
:interns {}},
:dirac.runtime.deps {:aliases {},
:interns {}},
:re-frame.utils {:aliases {},
:interns {}},
:clojure.set {:aliases {},
:interns {:intersection {:arglists "([s1] [s1 s2] [s1 s2 & sets])"},
:superset? {:arglists "([set1 set2])"},
:index {:arglists "([xrel ks])"},
:bubble-max-key {:arglists "([k coll])"},
:subset? {:arglists "([set1 set2])"},
:rename {:arglists "([xrel kmap])"},
:rename-keys {:arglists "([map kmap])"},
:project {:arglists "([xrel ks])"},
:difference {:arglists "([s1] [s1 s2] [s1 s2 & sets])"},
:union {:arglists "([] [s1] [s1 s2] [s1 s2 & sets])"},
:map-invert {:arglists "([m])"},
:join {:arglists "([xrel yrel] [xrel yrel km])"},
:select {:arglists "([pred xset])"}}},
:vr-secondview.autobahn {:aliases {},
:interns {}},
:devtools.protocols {:aliases {},
:interns {}},
:reagent.impl.component {:aliases {},
:interns {}},
:re-com.tabs {:aliases {},
:interns {}},
:vr-secondview.utils.helpers {:aliases {},
:interns {}},
:dirac.runtime.bootstrap {:aliases {},
:interns {}},
:devtools.hints {:aliases {},
:interns {}},
:vr-secondview.handlers {:aliases {},
:interns {}},
:com.stuartsierra.component {:aliases {:dep "com.stuartsierra.dependency",
:platform "com.stuartsierra.component.platform"},
:interns {:get-component {:arglists "([system key])"},
:update-system {:arglists "([system component-keys f & args])"},
:nil-component {:arglists "([system key])"},
:ex-without-components {:arglists "([error])"},
:get-dependency {:arglists "([system system-key component dependency-key])"},
:system-using {:arglists "([system dependency-map])"},
:assoc-dependencies {:arglists "([component system])"},
:start {:arglists "([component])"},
:dependency-graph {:arglists "([system component-keys])"},
:stop-system {:arglists "([system] [system component-keys])"},
:update-system-reverse {:arglists "([system component-keys f & args])"},
:map->SystemMap {:arglists "([m__6522__auto__])"},
:stop {:arglists "([component])"},
:assoc-dependency {:arglists "([system component dependency-key system-key])"},
:try-action {:arglists "([component system key f args])"},
:ex-component? {:arglists "([error])"},
:->SystemMap {:arglists "([])"},
:system-map {:arglists "([& keyvals])"},
:start-system {:arglists "([system] [system component-keys])"},
:Lifecycle {},
:using {:arglists "([component dependencies])"},
:dependencies {:arglists "([component])"}}},
:vr-secondview.utils.file-loader {:aliases {},
:interns {}},
:cljs.tools.reader.impl.utils {:aliases {},
:interns {}},
:cljs-time.internal.core {:aliases {},
:interns {}},
:re-frame.handlers {:aliases {},
:interns {}},
:vr-secondview.components.tour-viewer {:aliases {},
:interns {}},
:dirac.runtime {:aliases {},
:interns {}},
:re-com.alert {:aliases {},
:interns {}},
:re-com.datepicker {:aliases {},
:interns {}},
:dirac.runtime.output {:aliases {},
:interns {}},
:re-com.input-time {:aliases {},
:interns {}},
:clojure.browser.net {:aliases {},
:interns {}},
:re-frame.subs {:aliases {},
:interns {}},
:devtools.formatters.budgeting {:aliases {},
:interns {}},
:re-frame.middleware {:aliases {},
:interns {}},
:vr-secondview.db {:aliases {},
:interns {}},
:re-com.buttons {:aliases {},
:interns {}},
:devtools.format {:aliases {},
:interns {}},
:dirac.runtime.util {:aliases {},
:interns {}},
:cljs.core.async.impl.ioc-helpers {:aliases {},
:interns {}},
:cljs-time.format {:aliases {},
:interns {}},
:re-com.tour {:aliases {},
:interns {}},
:vr-secondview.devtools {:aliases {},
:interns {}},
:figwheel.client.socket {:aliases {},
:interns {}},
:devtools.core {:aliases {},
:interns {}},
:re-com.selection-list {:aliases {},
:interns {}},
:figwheel.client.heads-up {:aliases {},
:interns {}},
:cljs.reader {:aliases {},
:interns {}},
:re-com.dropdown {:aliases {},
:interns {}},
:vr-secondview.components.tour-selector {:aliases {},
:interns {}},
:vr-secondview.config {:aliases {},
:interns {}},
:re-com.misc {:aliases {},
:interns {}},
:re-com.splits {:aliases {},
:interns {}},
:re-frame.db {:aliases {},
:interns {}},
:re-frame.core {:aliases {},
:interns {}},
:cljs.core.async.impl.timers {:aliases {},
:interns {}},
:cljs-time.predicates {:aliases {},
:interns {}},
:cljs.user {:aliases {},
:interns {}},
:re-com.modal-panel {:aliases {},
:interns {}},
:clojure.browser.event {:aliases {},
:interns {}},
:vr-secondview.components.client-list {:aliases {},
:interns {}},
:reagent.impl.util {:aliases {},
:interns {}},
:devtools.formatters.core {:aliases {},
:interns {}},
:devtools.formatters.helpers {:aliases {},
:interns {}},
:vr-secondview.core {:aliases {},
:interns {}},
:cljs.core.async.impl.channels {:aliases {},
:interns {}},
:vr-secondview.routes {:aliases {},
:interns {}},
:cljs.core.async.impl.dispatch {:aliases {},
:interns {}},
:re-com.util {:aliases {},
:interns {}},
:cljs.tools.reader.impl.commons {:aliases {},
:interns {}},
:vr-secondview.views {:aliases {},
:interns {}},
:re-frame-tracer.core {:aliases {},
:interns {}},
:clojure.reflect {:aliases {:set "clojure.set",
:str "clojure.string"},
:interns {:map->Method {:arglists "([m__6522__auto__])"},
:field->map {:arglists "([field])"},
:internal-name->class-symbol {:arglists "([d])"},
:typename {:arglists "([o])"},
:->JavaReflector {:arglists "([classloader])"},
:->AsmReflector {:arglists "([class-resolver])"},
:resolve-class {:arglists "([this name])"},
:constructor->map {:arglists "([constructor])"},
:flag-descriptors {},
:parse-flags {:arglists "([flags context])"},
:do-reflect {:arglists "([reflector typeref])"},
:resource-name {:arglists "([typeref])"},
:ClassResolver {},
:parse-method-descriptor {:arglists "([md])"},
:Reflector {},
:field-descriptor->class-symbol {:arglists "([d])"},
:declared-fields {:arglists "([cls])"},
:typesym {:arglists "([t])"},
:declared-methods {:arglists "([cls])"},
:map->Constructor {:arglists "([m__6522__auto__])"},
:->Constructor {:arglists "([name declaring-class parameter-types exception-types flags])"},
:type-reflect {:arglists "([typeref & options])"},
:method->map {:arglists "([method])"},
:->Field {:arglists "([name type declaring-class flags])"},
:default-reflector {},
:access-flag {:arglists "([[name flag & contexts]])"},
:declared-constructors {:arglists "([cls])"},
:->Method {:arglists "([name return-type declaring-class parameter-types exception-types flags])"},
:TypeReference {},
:reflect {:arglists "([obj & options])"},
:map->Field {:arglists "([m__6522__auto__])"}}},
:devtools.toolbox {:aliases {},
:interns {}},
:vr-secondview.subs {:aliases {},
:interns {}},
:user {:aliases {:component "com.stuartsierra.component"},
:interns {:javadoc {:arglists "([class-or-object])"},
:find-doc {:arglists "([re-string-or-pattern])"},
:system {},
:deep-merge {:arglists "([& vals])"},
:cljs-repl {:arglists "([] [id])"},
:dir {:arglists "([nsname])",
:macro "true"},
:figwheel-config {},
:pst {:arglists "([] [e-or-depth] [e depth])"},
:pp {:arglists "([])",
:macro "true"},
:start {:arglists "([])"},
:source {:arglists "([n])",
:macro "true"},
:stop {:arglists "([])"},
:sass-config {},
:->Figwheel {:arglists "([])"},
:->SassWatcher {:arglists "([executable-path input-dir output-dir])"},
:repl {:arglists "([])"},
:map->SassWatcher {:arglists "([m__6522__auto__])"},
:reload {:arglists "([])"},
:apropos {:arglists "([str-or-pattern])"},
:map->Figwheel {:arglists "([m__6522__auto__])"},
:start-figwheel! {},
:doc {:arglists "([name])",
:macro "true"},
:pprint {:arglists "([object] [object writer])"},
:stop-figwheel! {:arglists "([])"}}},
:figwheel.connect.dev {:aliases {},
:interns {}},
:cljs.tools.reader.edn {:aliases {},
:interns {}},
:devtools.formatters.printing {:aliases {},
:interns {}},
:devtools.formatters.templating {:aliases {},
:interns {}}},
:id "f170bf75-0c52-4801-84a2-4dc3129bf993",
:repl-type "clj",
:session "4b167080-2237-44ef-ad51-85815ab2f023",
:status ["state"]}@Ninerian Hmm, that nREPL message looks like Cursive trying to communicate something to nREPL server and the message gets processed by Dirac middleware. Can you describe your workflow? This should not happen under normal circumstances. Also the problem is that this Cursive message contains some Clojure-isms, so pr-str in Clojure does not encode edn which would be consumable by read-string in ClojureScript. That is why my web-socket unserialization breaks.
At least I wrote more robust handling of this case in ws-client.
Ninerian
commented
7 years ago Actually I start a figwheel dev environment, using a combination of dirac and the workflow, documented in the figwheel wiki.
I start a Repl with the dev profile. After it's loaded, I load the repl.clj to start figwheel. Formerly I loaded the repl.js directly from the REPL profile, as in the wiki. But with dirac, I have to load the profile, which is not possible, when loading the repl through the JVM process.
In the core namespace I initialize dirac with (dirac.runtime/install!).
You may notice the commented part in the project.clj. This is my attempt to load figwheel and dirac directly. I had asked you about on the slack channel on Nov. 18.
My project.clj:
(defproject vr-secondview "0.4.0"
:dependencies [[org.clojure/clojure "1.8.0"]
[org.clojure/clojurescript "1.9.76"]
[org.clojure/data.xml "0.1.0-beta1"]
[org.clojure/data.zip "0.1.2"]
[into-edn "1.0.2"]
[com.taoensso/tufte "1.1.0"]
[com.taoensso/timbre "4.7.4"]
[org.clojure/core.async "0.2.385"]
[reagent "0.5.1"]
[re-frame "0.7.0"]
[re-com "0.8.3"]
[secretary "1.2.3"]
[garden "1.3.2"]
[funcool/tubax "0.2.0"]
[sundbry/autobahn.cljs "0.1.2-SNAPSHOT"]
[org.clojars.stumitchell/clairvoyant "0.2.0"]
[day8/re-frame-tracer "0.1.1-SNAPSHOT"]
;; For Dirac DevTools
[environ "1.1.0"]]
:source-paths ["src/clj" "src/cljs"]
:plugins [[lein-cljsbuild "1.1.3"]
[lein-garden "0.2.6"]
[lein-ancient "0.6.8"]
[lein-sassc "0.10.4"]
[lein-environ "1.1.0"]
[lein-figwheel "0.5.8"]]
:clean-targets ^{:protect false} ["resources/public/js/compiled" "target" "resources/production"
"test/js"
"resources/public/css/compiled"]
:figwheel {;:server-port 7111
:css-dirs ["resources/public/css"]
:repl false}
:garden {:builds [{:id "screen"
:source-paths ["src/clj"]
:stylesheet vr-secondview.css/screen
:compiler {:output-to "resources/public/css/compiled/screen.css"
:pretty-print? true}}]}
:profiles {:dev {:dependencies [[lein-figwheel "0.5.8"]
[figwheel-sidecar "0.5.8"]
[binaryage/devtools "0.8.3"]
[binaryage/dirac "0.8.4"]
]
:env {:devtools "true"}
:repl-options {:port 8230
:nrepl-middleware [dirac.nrepl/middleware]
:init (do
(require 'dirac.agent)
(dirac.agent/boot!))
}
:cljsbuild {:builds {:dev {:source-paths ["dev-resources"]}}}
}
;:repl {:repl-options {:port 8230
; :nrepl-middleware [dirac.nrepl/middleware]
; :init (do
; (require 'dirac.agent)
; (dirac.agent/boot!))
; }}
;:figwheel-nrepl
; [:figwheel-config
; ; following https://github.com/bhauman/lein-figwheel/wiki/Using-the-Figwheel-REPL-within-NRepl
; { :figwheel {:on-jsload "vr-secondview.core/mount-root"
; ;:websockewt-url "wss://daniel.dev/figwheel-ws"
; }
; :dependencies [[figwheel-sidecar "0.5.8"]]
; :repl-options {:init ^:replace (do
; (require 'dirac.agent)
; (use 'figwheel-sidecar.repl-api)
; (start-figwheel!
; {:figwheel-options {:server-port 7111} ;; <-- figwheel server config goes here
; :build-ids ["dirac"] ;; <-- a vector of build ids to start autobuilding
; :all-builds ;; <-- supply your build configs here
; [{:id "dirac"
; :figwheel true
; :source-paths ["src/cljs"]
; :compiler {:closure-defines {"clairvoyant.core.devmode" true}
; :output-to "resources/public/js/compiled/app.js"
; :output-dir "resources/public/js/compiled/out"
; :asset-path "js/compiled/out"
; :optimizations :none
; :source-map true
; :source-map-timestamp true
; :preloads ['devtools.preload 'dirac.runtime.preload]
; :main 'vr-secondview.core
; }}]})
; (dirac.agent/boot!)
; #_(cljs-repl))
;
; }
; }]
}
:sassc [{:output-to "resources/production/css/main.css" ;; default "target/sassc/main.css"
:style "compressed" ;; "nested" or "compressed", default "nested"
:import-path "src/scss"}] ;; default "src/scss"
:cljsbuild {:builds {:dev {:source-paths ["src/cljs"]
:figwheel {:on-jsload "vr-secondview.core/mount-root"
;:websocket-url "wss://daniel.dev/figwheel-ws"
}
:compiler {
:main vr-secondview.core
:preloads [devtools.preload dirac.runtime.preload]
:external-config {:dirac.runtime/config {:agent-host "daniel.dev"}}
:closure-defines {"clairvoyant.core.devmode" true}
:output-to "resources/public/js/compiled/app.js"
:output-dir "resources/public/js/compiled/out"
:asset-path "js/compiled/out"
:optimizations :none
:source-map true
:source-map-timestamp true}}
:test {:source-paths ["src/cljs" "test/cljs"]
:notify-command ["phantomjs" "test/unit-test.js" "test/unit-test.html"]
:compiler {:optimizations :whitespace
:pretty-print true
:output-to "test/js/app_test.js"
;:warnings {:single-segment-namespace false}
}
}
:min {:source-paths ["src/cljs"]
:compiler {:main vr-secondview.core
:output-to "resources/production/js/app.min.js"
:output-dir "resources/production/js"
:source-map "resources/production/js/app.js.map"
:optimizations :advanced
:externs ["resources/public/vendor/js/tour.ext.js"]
:closure-defines {goog.DEBUG false}
:pretty-print false
:parallel-build true}}}}
:aliases {
"develop" ["with-profile" "+dev" "figwheel"]
;"figwheel-repl" ["with-profile" "+figwheel-nrepl" "repl"]
"production" ["do" "clean" ["cljsbuild" "once" "min"] ["sassc" "once"]]})And the repl.clj
(require
'[dirac.agent]
'[figwheel-sidecar.repl-api :refer [start-figwheel! cljs-repl stop-figwheel!]]
'[com.stuartsierra.component :as component])
(import 'java.lang.Runtime)
(defn deep-merge
"Recursively merges maps. If keys are not maps, the last value wins."
[& vals]
(cond
(every? map? vals) (apply merge-with deep-merge vals)
(every? vector? vals) (into [] (reduce concat vals))
:else (-> vals
concat)))
(def figwheel-config
(let [p (figwheel-sidecar.config/get-project-config)
cljsbuild (get-in p [:cljsbuild :builds :dev])
profile (get-in p [:profiles :dev])
cljs-devbuild (get-in profile [:cljsbuild :builds :dev])
build (deep-merge {:id "dev"} cljsbuild cljs-devbuild)
figwheel (:figwheel p)]
{:figwheel-options figwheel
:build-ids ["dev"]
:all-builds
[build]}))
;(start-figwheel! {:all-builds (figwheel-sidecar.config/prep-builds [config])})
(def sass-config
{:executable-path "/usr/local/var/rbenv/shims/sass" ; e.g. /usr/local/bin/sass
:input-dir "src/scss" ; location of the sass/scss files
:output-dir "resources/public/css"})
(defrecord Figwheel []
component/Lifecycle
(start [config]
(start-figwheel! config)
config)
(stop [config]
(stop-figwheel!)
config))
(defrecord SassWatcher [executable-path input-dir output-dir]
component/Lifecycle
(start [config]
(if (not (:sass-watcher-process config))
(do
(println "Figwheel: Starting SASS watch process")
(assoc config :sass-watcher-process
(.exec (Runtime/getRuntime)
(str executable-path " --watch " input-dir ":" output-dir))))
config))
(stop [config]
(when-let [process (:sass-watcher-process config)]
(println "Figwheel: Stopping SASS watch process")
(.destroy process))
config))
(def system
(atom
(component/system-map
:figwheel (map->Figwheel figwheel-config)
:sass (map->SassWatcher sass-config))))
(defn start []
(swap! system component/start))
(defn stop []
(swap! system component/stop))
(defn reload []
(stop)
(start))
(defn repl []
(cljs-repl))
;; Start the components and the repl
(start)@Ninerian I'm not able to parse and validate your project.clj in my head. It would be more helpful if you could create a sample project and give me a link to a git repo. Then I could go fork it and possibly fix it after testing the real thing on my machine.
darwin
commented
7 years ago Original issue as reported by @njj fixed by 546f63b7710247ed31e525c72fb8f64a9815f8e6 in v0.8.5.
@Ninerian if you still have problems please open a separate bug report. Also this document might help: https://github.com/binaryage/dirac/blob/master/docs/about-repls.md#dirac--figwheel
Recently updated to the newest version and I'm seeing this: