-
-
Save marciol/660962be1871f3b9c273815ed58b306d to your computer and use it in GitHub Desktop.
My Chlorine Config
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
(defn explain-schema [] | |
(p/let [editor-data (editor/get-var)] | |
(when editor-data | |
(-> editor-data | |
(update :text #(str "(if (satisfies? schema.core/Schema " % ") " | |
"(schema.core/explain " % ")" | |
"(or #?(:cljs nil :default (:schema (meta (ns-resolve *ns* '" % "))))" | |
"\"Is not a schema\"))")) | |
(editor/eval-and-render))))) | |
(defn fqn-of-var [] | |
(p/let [editor-data (editor/get-var)] | |
(-> editor-data | |
(update :text #(str "`" %)) | |
editor/eval-and-render))) | |
(defn notify [] | |
(p/let [res (editor/run-callback | |
:prompt {:title "What do you want?" | |
:message (str "How do you want to evaluate " | |
"your code?") | |
:arguments [{:key :top :value "Top Block"} | |
{:key :block :value "Block"} | |
{:key :var :value "Current Var"}]}) | |
{:keys [text]} (case res | |
:top (editor/get-top-block) | |
:block (editor/get-block) | |
:var (editor/get-var))] | |
(editor/run-callback :notify {:type :info :title text}))) | |
(defn example-notify [] | |
(let [res '(fn [_] (editor/run-callback | |
:notify {:type :info :title "LOL!"}))] | |
(editor/eval-interactive {:range [[0 0] [0 0]] | |
:text (str "{:html [:a {:on-click '" | |
res | |
"} \"Something\"]}")}))) | |
(defn dependencies-of-block [] | |
(p/let [{curr-ns :text} (editor/get-namespace) | |
{curr-txt :text curr-range :range} (editor/get-top-block) | |
code (str "(->> `" curr-txt | |
" (tree-seq coll? seq)" | |
" rest" | |
" (filter #(not (coll? %)))" | |
" (filter symbol?)" | |
" (filter namespace)" | |
" (remove #(#{" (pr-str curr-ns) | |
" \"clojure.core\"" | |
" \"cljs.core\"}" | |
" (namespace %)))" | |
" (remove #(clojure.string/starts-with? (str %) \".\"))" | |
" (group-by namespace)" | |
" (mapcat (fn [[ns names]] (map #(vector ns (str (name %))) names)))" | |
" vec)") | |
code (str "{:html [:div.pre [:p/diag (doto " code " prn)]]}")] | |
(editor/eval-interactive {:text code :range curr-range}))) | |
(defn- counter [c] | |
(let [s (r/atom 0) | |
f (fn [] | |
[:div "Clicked " [:button {:on-click (fn [_] | |
(swap! s inc))} | |
@s] | |
" time(s) - " c])] | |
[f])) | |
(render/register-reagent :p/counter counter) | |
(defn hello [ & args] | |
(doto (render/create-tag "div") | |
(render/set-text 10))) | |
(render/register-tag :p/hello hello) | |
(def ^:private nomno (render/js-require "./chlorine/nomno")) | |
(defn- parse-nomno [data-struct] | |
(if (empty? data-struct) | |
"[*]" | |
(reduce (fn [acc [k v]] | |
(str acc "[" k "]->[" v "]\n")) | |
"#direction: right\n" | |
data-struct))) | |
(defn- diag [txt] | |
(doto (render/create-tag "div") | |
(render/set-html ((aget nomno "renderSvg") | |
(cond-> txt (not (string? txt)) parse-nomno))))) | |
(render/register-tag :p/diag diag) | |
(defn as-diagram [] | |
(p/let [res (editor/get-top-block)] | |
(editor/eval-interactive | |
(update res :text #(str "{:html [:div [:p/diag " | |
% | |
"]]}"))))) | |
; (prn :RES res) | |
; (editor/eval-interactive | |
; (update res :text #(str "{:html [:div [:p/diag " | |
; (str/trim (pr-str %)) | |
; "]]}"))))) | |
(def ^:private plant-uml (render/js-require "chlorine/plant")) | |
(defn- plant [txt] | |
(p/let [div (render/create-tag "div") | |
svg (plant-uml txt)] | |
(doto (render/create-tag "div") | |
(render/set-html svg)))) | |
(render/register-tag :plant/uml plant) | |
; (declare parse-elem) | |
; (defn- parse-list [[fst & r]] | |
; (prn :PARSING fst) | |
; (cond | |
; (= 'def fst) (parse-elem (second r)) | |
; (= 'fn* fst) (parse-elem (cons 'do (->> r first rest))) | |
; (= 'if fst) (when-let [[c t f] r] | |
; ; (when-let [s :FOO] | |
; [(str "[<question>" (first (parse-elem c)) "]") | |
; (first (parse-elem t)) | |
; ; s | |
; (str "[<question>" (parse-elem c) "]") | |
; (first (parse-elem f))]) | |
; ; s]) | |
; (= 'do fst) (mapcat parse-elem r) | |
; :else [(pr-str (cons fst r))])) | |
; | |
; (defn- parse-elem [elem] | |
; (prn :LIST? (list? elem) elem) | |
; (if (list? elem) | |
; (parse-list elem) | |
; (pr-str elem))) | |
; | |
; (defn- normalize-tags [tags] | |
; (let [tags (concat ["[<st> s]"] tags ["[<ed> e]"])] | |
; (str "#.question: visual=rhomb\n" | |
; "#.st: visual=start\n" | |
; "#.ed: visual=end\n\n" | |
; (->> tags | |
; (partition 2 1) | |
; (map (fn [[a b]] (str a "->" b))) | |
; (str/join "\n"))))) | |
; | |
; (defn flowchart-for [] | |
; (let [opts (editor/get-top-block) | |
; txt (str "(clojure.walk/macroexpand-all '" (:text opts) ")") | |
; {:keys [result]} (editor/eval txt (:range opts)) | |
; tags (parse-elem result) | |
; norm (normalize-tags tags)] | |
; | |
; (prn tags) | |
; (println norm) | |
; #_ | |
; (println | |
; (str "#.question: visual=rhomb\n" | |
; "#.st: visual=start\n" | |
; "#.ed: visual=end\n\n" | |
; "[<st> s]->" | |
; ; (parse-elem result) | |
; "[<ed> e]")))) | |
(declare parse-elem) | |
(defn- parse-list [prev acc [fst & r]] | |
(case fst | |
def (parse-elem prev acc (second r)) | |
fn* (parse-elem prev acc (cons 'do (->> r first rest))) | |
if (let [after-conds (gensym) | |
[c t f] r] | |
(swap! acc assoc after-conds {:type :connector :next []}) | |
(let [if-sym (parse-elem prev acc c) | |
true-sym (parse-elem if-sym acc t) | |
false-sym (some->> f (parse-elem if-sym acc))] | |
(swap! acc #(cond-> (update % true-sym assoc :connector "Y" :next [after-conds]) | |
false-sym | |
(update false-sym assoc :connector "N" :next [after-conds]) | |
(nil? false-sym) | |
(update-in [if-sym :next] conj after-conds))) | |
(swap! acc update if-sym assoc :type :question) | |
after-conds)) | |
do (let [actual (atom prev)] | |
(doseq [elem r | |
:let [sym (parse-elem @actual acc elem)]] | |
(reset! actual sym)) | |
@actual) | |
(let [elem (cons fst r) | |
sym (gensym)] | |
(swap! acc assoc sym {:text (pr-str elem) :next []}) | |
(swap! acc update-in [prev :next] conj sym) | |
sym))) | |
(defn- parse-elem [prev acc elem] | |
; (prn :PARSING (seq? elem) elem) | |
(if (seq? elem) | |
(parse-list prev acc elem) | |
(let [sym (gensym)] | |
(swap! acc assoc sym {:text (pr-str elem) :next []}) | |
(swap! acc update-in [prev :next] conj sym) | |
sym))) | |
(defn- normalize-tags [tags] | |
(let [elem-name (fn [{:keys [type text connector]}] | |
(str "[" | |
(case type | |
:connector "<conn> '" | |
:start "<st> s" | |
:end "<ed> e" | |
:question "<question> " | |
"") | |
text | |
"]")) | |
seed (str "#.question: visual=rhomb\n" | |
"#.conn: visual=none\n" | |
"#.st: visual=start\n" | |
"#.ed: visual=end\n\n")] | |
(reduce (fn [sofar elem] | |
(->> (:next elem) | |
(reduce (fn [sofar next-key] | |
(let [next-elem (get tags next-key)] | |
(str sofar "\n" | |
(elem-name elem) | |
"->" (:connector next-elem) | |
(elem-name next-elem)))) | |
sofar))) | |
seed (vals tags)))) | |
; (defn flowchart-for [] | |
; (p/let [opts (editor/get-top-block) | |
; txt (str "(clojure.walk/macroexpand-all '" (:text opts) ")") | |
; {:keys [result]} (editor/eval txt (:range opts)) | |
; acc (atom {:st {:type :start :next []} :ed {:type :end}}) | |
; last-sym (parse-elem :st acc result)] | |
; | |
; | |
; (println (normalize-tags @acc)) | |
; (editor/eval-interactive {:text (str "'{:html [:div [:p/diag " | |
; (pr-str (normalize-tags @acc)) | |
; "]]}") | |
; :range (:range opts)}))) | |
(defn shadow-runtimes [] | |
(p/let [data (editor/get-selection) | |
{:keys [result]} (editor/eval {:text (pr-str {:op :request-clients, | |
:query [:eq :type :runtime]}) | |
:shadow-command true | |
:filename "eval_user.cljs" | |
:range (:range data)}) | |
clients (->> (:clients result) | |
(map :client-info) | |
(mapv #(select-keys % [:user-agent :desc :build-id])))] | |
(editor/eval-interactive | |
{:text (pr-str {:html [:div.rows | |
[:div.title "Shadow Runtimes"] | |
[:<> | |
''(for [{:keys [desc build-id user-agent]} ?state] | |
[:ul | |
[:li | |
(or desc user-agent)] " " (pr-str build-id)])]] | |
:state clients}) | |
:range (:range data)}))) | |
(def last-command (atom {:text "" | |
:namespace ""})) | |
(defn eval-and-save [] | |
(p/let [txt (editor/get-block) | |
namespace (editor/get-namespace)] | |
(reset! last-command {:text (:text txt) | |
:namespace (:text namespace)}) | |
(editor/eval-and-render txt))) | |
(defn repeat-last-eval [] | |
(p/let [{:keys [range]} (editor/get-selection)] | |
(editor/eval-and-render {:range range | |
:text (:text @last-command) | |
:namespace (:namespace @last-command)}))) | |
(def old-fail-blob | |
'(defmethod clojure.test/report :fail [m] | |
(clojure.test/with-test-out | |
(clojure.test/inc-report-counter :fail) | |
(println "\nFAIL in" (clojure.test/testing-vars-str m)) | |
(when (seq clojure.test/*testing-contexts*) (println (clojure.test/testing-contexts-str))) | |
(when-let [message (:message m)] (println message)) | |
(println "expected:" (pr-str (:expected m))) | |
(println " actual:" (pr-str (:actual m)))))) | |
(def old-error-blob | |
'(defmethod clojure.test/report :error [m] | |
(clojure.test/with-test-out | |
(clojure.test/inc-report-counter :error) | |
(println "\nERROR in" (clojure.test/testing-vars-str m)) | |
(when (seq clojure.test/*testing-contexts*) (println (clojure.test/testing-contexts-str))) | |
(when-let [message (:message m)] (println message)) | |
(println "expected:" (pr-str (:expected m))) | |
(print " actual: ") | |
(let [actual (:actual m)] | |
(if (instance? Throwable actual) | |
(clojure.stacktrace/print-cause-trace actual clojure.test/*stack-trace-depth*) | |
(prn actual)))))) | |
(def html-for-tests | |
'{:html '(if (empty? ?state) | |
[:div.title "All tests passed"] | |
[:div.rows | |
[:div.title.error "Test(s) failed!"] | |
[:<> | |
(map (fn [error idx] | |
[:div.rows {:key idx} | |
[:div.space] | |
[:div.title | |
(-> error :type name str/upper-case) " at: " | |
[:a {:href "#" | |
:on-click (fn [_] (editor/run-callback :open-editor | |
{:file-name (:file error) | |
:line (dec (:line error))}))} | |
(:file error) ":" (:line error)]] | |
(if (-> error :type (= :error)) | |
[:div/clj (:actual error)] | |
[:div/ansi (:actual error)])]) | |
; [:a {:href "#" :on-click (fn [_] | |
; (editor/eval-interactive "__PLACE_HOLDER_HERE__"))} | |
; "Re-run test")]) | |
?state (range))]]) | |
:state @s}) | |
(defn eval-block-as-test [] | |
(p/let [txt-code (editor/get-block) | |
code (str "(let [s (atom [])] " | |
" (defmethod clojure.test/report :error [m]" | |
" (swap! s conj m))" | |
" (defmethod clojure.test/report :fail [m]" | |
" (swap! s conj (update m :actual pr-str))) " | |
(:text txt-code) " " | |
(pr-str old-fail-blob) " " | |
(pr-str old-error-blob) " " | |
html-for-tests " )") | |
obj {:range (:range txt-code) | |
:text (str code)}] | |
(editor/eval-interactive obj))) | |
(editor/run-callback :notify {:type :info :title "Config reloaded"}) |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
cd ~/.atom/ | |
mkdir chlorine/ | |
cd chlorine | |
npm install nomnoml plantuml | |
echo "module.exports = require('nomnoml');" > nomno.js | |
echo "module.exports = require('plantuml');" > plant.js |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment