def conduct_handshake(self):
server = self.server
# Client starts io-prepl
server.recv()
# Client sends version print
server.recv()
server.send({
edn.Keyword("tag"): edn.Keyword("out"),
edn.Keyword("val"): """Babashka 0.3.6""",
})
server.send({
edn.Keyword("tag"):
edn.Keyword("ret"),
edn.Keyword("val"):
"nil",
edn.Keyword("ns"):
"user",
edn.Keyword("ms"):
0,
edn.Keyword("form"):
"""(println "Babashka" (System/getProperty "babashka.version"))""",
})
def test_get_view_dialect(self):
self.view.assign_syntax(
"Packages/Tutkain/Clojure (Tutkain).sublime-syntax")
self.assertEquals(edn.Keyword("clj"), dialects.for_view(self.view))
self.view.assign_syntax(
"Packages/Tutkain/ClojureScript (Tutkain).sublime-syntax")
self.assertEquals(edn.Keyword("cljs"), dialects.for_view(self.view))
self.view.assign_syntax(
"Packages/Tutkain/Clojure Common (Tutkain).sublime-syntax")
self.assertEquals(edn.Keyword("clj"), dialects.for_view(self.view))
self.view.window().settings().set("tutkain_evaluation_dialect", "cljs")
self.assertEquals(edn.Keyword("cljs"), dialects.for_view(self.view))
self.view.window().settings().set("tutkain_evaluation_dialect", "clj")
self.assertEquals(edn.Keyword("clj"), dialects.for_view(self.view))
def setUpClass(self):
super().setUpClass(syntax="Babashka (Tutkain).sublime-syntax")
start_logging(False)
def write_greeting(buf):
buf.write("Babashka v0.3.6 REPL.\n")
buf.flush()
buf.write("Use :repl/quit or :repl/exit to quit the REPL.\n")
buf.flush()
buf.write("Clojure rocks, Bash reaches.\n")
buf.flush()
buf.write("\n")
buf.flush()
buf.write("user=> ")
buf.flush()
self.server = Server(greeting=write_greeting)
self.server.start()
self.client = BabashkaClient(source_root(), self.server.host,
self.server.port)
self.server.executor.submit(self.client.connect)
dialect = edn.Keyword("bb")
state.set_view_client(self.view, dialect, self.client)
repl_view = self.view.window().new_file()
views.configure(repl_view, dialect, self.client)
state.set_view_client(repl_view, dialect, self.client)
state.set_repl_view(repl_view, dialect)
self.conduct_handshake()
def setUpClass(self):
super().setUpClass(syntax="ClojureScript (Tutkain).sublime-syntax")
start_logging(False)
def write_greeting(buf):
buf.write("shadow-cljs - REPL - see (help)\n")
buf.flush()
buf.write("To quit, type: :repl/quit\n")
buf.flush()
buf.write("shadow.user=> ")
buf.flush()
self.server = Server(greeting=write_greeting)
self.server.start()
self.client = JSClient(source_root(), self.server.host,
self.server.port, lambda _, on_done: on_done(1))
self.server.executor.submit(self.client.connect)
dialect = edn.Keyword("cljs")
state.set_view_client(self.view, dialect, self.client)
repl_view = self.view.window().new_file()
views.configure(repl_view, dialect, self.client)
state.set_view_client(repl_view, dialect, self.client)
state.set_repl_view(repl_view, dialect)
self.backchannel = self.conduct_handshake()
def print_item(self, ns, code):
return {
"printable": f"""{ns}=> {code}\n""",
"response": {
edn.Keyword("in"): f"""{code}"""
}
}
def test_get_point_dialect(self):
self.view.assign_syntax(
"Packages/Tutkain/Clojure (Tutkain).sublime-syntax")
self.set_view_content("""(Integer/parseInt "42")""")
self.assertEqual(edn.Keyword("clj"), dialects.for_point(self.view, 0))
self.view.assign_syntax(
"Packages/Tutkain/ClojureScript (Tutkain).sublime-syntax")
self.set_view_content("""(js/parseInt "42")""")
self.assertEqual(edn.Keyword("cljs"), dialects.for_point(self.view, 0))
self.view.assign_syntax(
"Packages/Tutkain/Clojure Common (Tutkain).sublime-syntax")
self.set_view_content("""(inc 1)""")
self.assertEqual(edn.Keyword("clj"), dialects.for_point(self.view, 0))
self.view.assign_syntax("Packages/Markdown/Markdown.sublime-syntax")
self.set_view_content("""# Hello, world!""")
self.assertEqual(None, dialects.for_point(self.view, 0))
def test_roundtrip(self):
for val in [
None,
True,
False,
42,
0,
# -42,
"Hello, world!",
"foo \"bar\" quux\\n",
"äö",
[],
["spam", 42, 84],
set([1, 2, 3]),
edn.Keyword("foo"),
edn.Keyword("bar", "foo"),
{
"foo": 42,
"bar": "spam"
},
["cheese", 42, {
"ham": "eggs"
}],
{
"cheese": 42,
"ham": ["eggs"]
},
{
"status": ["error", "namespace-not-found", "done"],
"id": 11
},
{
"a": []
},
{
"a": [{
"b": "c"
}]
},
{
edn.Keyword("a"): [{
edn.Keyword("b"): edn.Keyword("c")
}]
},
]:
edn.write(self.buffer, val)
self.assertEqual(val, edn.read_line(self.buffer))
def eval_context(self, ns="user", file="NO_SOURCE_FILE", line=1, column=1):
actual = edn.read(self.backchannel.recv())
id = actual.get(edn.Keyword("id"))
response = edn.kwmap({
"id": id,
"op": edn.Keyword("set-eval-context"),
"file": file,
"line": line,
"column": column,
})
self.assertEquals(response, actual)
self.backchannel.send(
edn.kwmap({
"id": id,
"file": file,
"ns": edn.Symbol(ns)
}))
def test_issue_46(self):
code = """(apply str (repeat 9126 "x"))"""
self.set_view_content(code)
self.set_selections((0, 0))
self.view.run_command("tutkain_evaluate", {"scope": "innermost"})
self.eval_context()
self.assertEquals(self.print_item("user", code), self.get_print())
retval = "x" * 9126
response = edn.kwmap({"tag": edn.Keyword("ret"), "val": retval})
self.assertEquals(code + "\n", self.server.recv())
self.server.send(response)
self.assertEqual({
"printable": retval,
"response": response
}, self.get_print())
def setUpClass(self):
super().setUpClass()
start_logging(False)
def write_greeting(buf):
buf.write("user=> ")
buf.flush()
self.server = Server(greeting=write_greeting).start()
self.client = JVMClient(source_root(), self.server.host,
self.server.port)
self.server.executor.submit(self.client.connect)
dialect = edn.Keyword("clj")
state.set_view_client(self.view, dialect, self.client)
repl_view = self.view.window().new_file()
views.configure(repl_view, dialect, self.client)
state.set_view_client(repl_view, dialect, self.client)
state.set_repl_view(repl_view, dialect)
self.backchannel = self.conduct_handshake()
def test_view(self):
self.set_view_content("(ns foo.bar) (defn x [y] y)")
self.set_selections((0, 0))
self.view.run_command("tutkain_evaluate", {"scope": "view"})
response = edn.read(self.backchannel.recv())
self.assertEquals(
{
edn.Keyword("op"): edn.Keyword("load"),
edn.Keyword("code"): "(ns foo.bar) (defn x [y] y)",
edn.Keyword("file"): None,
edn.Keyword("id"): response.get(edn.Keyword("id"))
}, response)
def test_lookup_head(self):
self.set_view_content("(map inc )")
self.set_selections((9, 9))
self.view.run_command("tutkain_show_information", {
"selector": "variable.function",
"seek_backward": True
})
response = edn.read(self.backchannel.recv())
self.assertEquals(
{
edn.Keyword("op"): edn.Keyword("lookup"),
edn.Keyword("named"): "map",
edn.Keyword("ns"): None,
edn.Keyword("id"): response.get(edn.Keyword("id"))
}, response)
def test_lookup(self):
self.set_view_content("(rand)")
for n in range(1, 5):
self.set_selections((n, n))
self.view.run_command("tutkain_show_information",
{"selector": "variable.function"})
response = edn.read(self.backchannel.recv())
self.assertEquals(
{
edn.Keyword("op"): edn.Keyword("lookup"),
edn.Keyword("named"): "rand",
edn.Keyword("ns"): None,
edn.Keyword("id"): response.get(edn.Keyword("id"))
}, response)
def conduct_handshake(self):
server = self.server
# Client starts clojure.main/repl
server.recv()
# Client requests build IDs
server.recv()
# Server sends build ID list
server.send([
edn.Keyword("browser"),
edn.Keyword("node-script"),
edn.Keyword("npm")
])
# Client switches into the bootstrap namespace
server.recv()
server.send("nil\n")
# Client defines load-base64 function
server.recv()
server.send("#'tutkain.bootstrap/load-base64\n")
# Client loads modules
server.recv()
server.send("#'tutkain.format/pp-str")
server.recv()
server.send("#'tutkain.backchannel/open")
server.recv()
server.send("#'tutkain.repl/repl")
# Client starts REPL
server.recv()
with Server() as backchannel:
server.send({
edn.Keyword("host"): "localhost",
edn.Keyword("port"): backchannel.port
})
for _ in range(4):
backchannel.recv()
# Client sends version print
server.recv()
server.send({
edn.Keyword("tag"): edn.Keyword("out"),
edn.Keyword("val"): "ClojureScript 1.10.844"
})
server.send({
edn.Keyword("tag"): edn.Keyword("out"),
edn.Keyword("val"): "\\n"
})
server.send({
edn.Keyword("tag"):
edn.Keyword("ret"),
edn.Keyword("val"):
"nil",
edn.Keyword("ns"):
"cljs.user",
edn.Keyword("ms"):
0,
edn.Keyword("form"):
"""(println "ClojureScript" *clojurescript-version*)"""
})
# TODO: Add test for no runtime
return backchannel
def conduct_handshake(self):
server = self.server
# Client starts clojure.main/repl
server.recv()
# Client switches into the bootstrap namespace
server.recv()
server.send("nil\n")
# Client defines load-base64 function
server.recv()
server.send("#'tutkain.bootstrap/load-base64\n")
# Client loads modules
server.recv()
server.send("#'tutkain.format/pp-str")
server.recv()
server.send("#'tutkain.backchannel/open")
server.recv()
server.send("#'tutkain.repl/repl")
server.recv()
with Server() as backchannel:
server.send({
edn.Keyword("tag"):
edn.Keyword("ret"),
edn.Keyword("val"):
f"""{{:host "localhost", :port {backchannel.port}}}""",
})
for _ in range(4):
backchannel.recv()
server.send({
edn.Keyword("tag"): edn.Keyword("out"),
edn.Keyword("val"): "Clojure 1.11.0-alpha1"
})
server.send({
edn.Keyword("tag"):
edn.Keyword("ret"),
edn.Keyword("val"):
"nil",
edn.Keyword("ns"):
"user",
edn.Keyword("ms"):
0,
edn.Keyword("form"):
"""(println "Clojure" (clojure-version))"""
})
server.recv()
# Clojure version info is printed on the client
self.client.printq.get(timeout=5)
return backchannel
def test_smoke(self):
def write_greeting(buf):
buf.write("user=> ")
buf.flush()
with Server(greeting=write_greeting) as server:
client = JVMClient(source_root(), server.host, server.port)
server.executor.submit(client.connect)
# Client starts clojure.main/repl
server.recv()
# Client switches into the bootstrap namespace
server.recv()
server.send("nil\n")
# Client defines load-base64 function
server.recv()
server.send("#'tutkain.bootstrap/load-base64\n")
# Client loads modules
server.recv()
server.send("#'tutkain.format/pp-str")
server.recv()
server.send("#'tutkain.backchannel/open")
server.recv()
server.send("#'tutkain.repl/repl")
server.recv()
with Server() as backchannel:
server.send(
edn.kwmap({
"tag":
edn.Keyword("ret"),
"val":
f"""{{:host "localhost", :port {backchannel.port}}}""",
}))
for filename in [
"lookup.clj", "completions.clj", "load_blob.clj",
"test.clj"
]:
response = edn.read(backchannel.recv())
self.assertEquals(edn.Keyword("load-base64"),
response.get(edn.Keyword("op")))
self.assertEquals(filename,
response.get(edn.Keyword("filename")))
self.assertEquals("""(println "Clojure" (clojure-version))""",
server.recv().rstrip())
server.send({
edn.Keyword("tag"): edn.Keyword("out"),
edn.Keyword("val"): "Clojure 1.11.0-alpha1"
})
server.send({
edn.Keyword("tag"):
edn.Keyword("ret"),
edn.Keyword("val"):
"nil",
edn.Keyword("ns"):
"user",
edn.Keyword("ms"):
0,
edn.Keyword("form"):
"""(println "Clojure" (clojure-version))"""
})
self.assertEquals(
{
"printable": "Clojure 1.11.0-alpha1",
"response": {
edn.Keyword("tag"): edn.Keyword("out"),
edn.Keyword("val"): "Clojure 1.11.0-alpha1"
}
}, client.printq.get(timeout=1))
client.eval("(inc 1)")
response = edn.read(backchannel.recv())
id = response.get(edn.Keyword("id"))
self.assertEquals(
edn.kwmap({
"op": edn.Keyword("set-eval-context"),
"id": id,
"file": "NO_SOURCE_FILE",
"line": 1,
"column": 1
}), response)
backchannel.send(
edn.kwmap({
"id": id,
"file": None,
"ns": edn.Symbol("user"),
"dialect": edn.Keyword("clj")
}))
self.assertEquals("(inc 1)\n", server.recv())
response = edn.kwmap({
"tag": edn.Keyword("ret"),
"val": "2",
"ns": "user",
"ms": 1,
"form": "(inc 1)"
})
server.send(response)
self.assertEquals({
"printable": "2",
"response": response
}, client.printq.get(timeout=1))
client.halt()
self.assertEquals(":repl/quit\n", server.recv())
