rapydscript-ng 0.7.24 → 0.8.0

package/test/lsp.pyj

@@ -0,0 +1,222 @@
+# globals: assrt, fs, require, test_path, compiler_dir, console, RapydScript
+
+# Tests for the "lsp" sub-command (tools/lsp.mjs), the RapydScript language
+# server. These drive the pure analysis functions directly (the same functions
+# the JSON-RPC layer calls) plus the parser's error-recovery mode.
+
+lsp = require('./lsp.mjs')
+path = require('path')
+os = require('os')
+url = require('url')
+
+base_path = path.resolve(compiler_dir, '..')
+libdir = path.join(base_path, 'src', 'lib')
+
+def uri_of(p):
+    return url.pathToFileURL(p).href
+
+def offset_of(text, needle, from_index):
+    return text.indexOf(needle, from_index or 0)
+
+def make_ctx(tmp):
+    return lsp.create_server_context({
+        'import_dirs': [tmp], 'libdir': libdir, 'workspace_roots': [tmp],
+        'line_length': 80, 'preferred_quote': 'single',
+    })
+
+def write_workspace():
+    tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'rs-lsp-'))
+    fs.writeFileSync(path.join(tmp, 'util.pyj'),
+        'def helper(x):\n    return x + 1\n\nclass Widget:\n    def __init__(self):\n        self.n = 0\n')
+    fs.writeFileSync(path.join(tmp, 'main.pyj'),
+        'from util import helper\nimport util\n\ndef run():\n    w = util.Widget()\n    return helper(w)\n\nunused_var = 5\nmissing = undefined_thing()\nimport nonexistent_module\n')
+    return tmp
+
+def codes(diags):
+    ans = {}
+    for d in diags:
+        ans[d.code] = (ans[d.code] or 0) + 1
+    return ans
+
+async def test_diagnostics():
+    tmp = write_workspace()
+    ctx = make_ctx(tmp)
+    main_uri = uri_of(path.join(tmp, 'main.pyj'))
+    text = fs.readFileSync(path.join(tmp, 'main.pyj'), 'utf-8')
+    diags = await lsp.compute_diagnostics(ctx, main_uri, text)
+    c = codes(diags)
+    assrt.ok(c['undef'], 'expected an undef diagnostic for undefined_thing')
+    assrt.ok(c['unused-import'], 'expected unused-import for nonexistent_module')
+    assrt.ok(c['import-unresolved'], 'expected import-unresolved for nonexistent_module')
+    fs.rmSync(tmp, {'recursive': True})
+
+async def test_hover_and_definition():
+    tmp = write_workspace()
+    ctx = make_ctx(tmp)
+    main_uri = uri_of(path.join(tmp, 'main.pyj'))
+    util_uri = uri_of(path.join(tmp, 'util.pyj'))
+    text = fs.readFileSync(path.join(tmp, 'main.pyj'), 'utf-8')
+    off = offset_of(text, 'helper(w)')
+    h = await lsp.hover(ctx, main_uri, text, off)
+    assrt.ok(h and h.contents.value.indexOf('helper') >= 0, 'hover should mention helper')
+
+    defs = await lsp.definition(ctx, main_uri, text, off)
+    assrt.ok(Array.isArray(defs) and defs.length >= 1, 'definition should return locations')
+    assrt.equal(defs[0].uri, util_uri, 'definition of helper should be in util.pyj')
+    assrt.equal(defs[0].range.start.line, 0, 'helper is defined on line 0 of util.pyj')
+    fs.rmSync(tmp, {'recursive': True})
+
+async def test_cross_file_references():
+    tmp = write_workspace()
+    ctx = make_ctx(tmp)
+    main_uri = uri_of(path.join(tmp, 'main.pyj'))
+    util_uri = uri_of(path.join(tmp, 'util.pyj'))
+    text = fs.readFileSync(path.join(tmp, 'main.pyj'), 'utf-8')
+    off = offset_of(text, 'helper(w)')
+    refs = await lsp.references(ctx, main_uri, text, off, True)
+    uris = {}
+    for r in refs:
+        uris[r.uri] = True
+    assrt.ok(uris[main_uri], 'references should include occurrences in main.pyj')
+    assrt.ok(uris[util_uri], 'references should include the definition file util.pyj')
+    assrt.ok(refs.length >= 3, 'expected at least 3 references to helper across files')
+    fs.rmSync(tmp, {'recursive': True})
+
+async def test_cross_file_rename():
+    tmp = write_workspace()
+    ctx = make_ctx(tmp)
+    main_uri = uri_of(path.join(tmp, 'main.pyj'))
+    util_uri = uri_of(path.join(tmp, 'util.pyj'))
+    text = fs.readFileSync(path.join(tmp, 'main.pyj'), 'utf-8')
+    off = offset_of(text, 'helper(w)')
+    we = await lsp.rename(ctx, main_uri, text, off, 'compute')
+    assrt.ok(we and we.changes, 'rename should return a workspace edit')
+    assrt.ok(we.changes[main_uri] and we.changes[main_uri].length >= 2, 'main.pyj should have >= 2 edits')
+    assrt.ok(we.changes[util_uri] and we.changes[util_uri].length >= 1, 'util.pyj should have the definition edit')
+    for e in we.changes[util_uri]:
+        assrt.equal(e.newText, 'compute', 'edit should insert the new name')
+    fs.rmSync(tmp, {'recursive': True})
+
+async def test_invalid_rename():
+    tmp = write_workspace()
+    ctx = make_ctx(tmp)
+    main_uri = uri_of(path.join(tmp, 'main.pyj'))
+    text = fs.readFileSync(path.join(tmp, 'main.pyj'), 'utf-8')
+    off = offset_of(text, 'helper(w)')
+    threw = False
+    try:
+        await lsp.rename(ctx, main_uri, text, off, 'not a name')
+    except:
+        threw = True
+    assrt.ok(threw, 'renaming to an invalid identifier must be rejected')
+    fs.rmSync(tmp, {'recursive': True})
+
+async def test_local_rename():
+    tmp = write_workspace()
+    ctx = make_ctx(tmp)
+    uri = uri_of(path.join(tmp, 'local.pyj'))
+    text = 'def f():\n    total = 0\n    total = total + 1\n    return total\n'
+    we = await lsp.rename(ctx, uri, text, offset_of(text, 'return total') + 'return '.length, 'sum')
+    assrt.ok(we and we.changes and we.changes[uri], 'local rename should return edits')
+    assrt.equal(we.changes[uri].length, 4, 'total is used 4 times (1 def + 3 refs)')
+    fs.rmSync(tmp, {'recursive': True})
+
+async def test_completion():
+    tmp = write_workspace()
+    ctx = make_ctx(tmp)
+    main_uri = uri_of(path.join(tmp, 'main.pyj'))
+    text = fs.readFileSync(path.join(tmp, 'main.pyj'), 'utf-8')
+    # After "util." we should be offered the module's exports.
+    dot_off = offset_of(text, 'util.Widget') + 'util.'.length
+    items = await lsp.completions(ctx, main_uri, text, dot_off)
+    labels = [it.label for it in items]
+    assrt.ok(labels.indexOf('Widget') >= 0, 'member completion should include Widget')
+    assrt.ok(labels.indexOf('helper') >= 0, 'member completion should include helper')
+
+    # Bare completion should include in-scope symbols, builtins and keywords.
+    bare = await lsp.completions(ctx, main_uri, text, offset_of(text, 'unused_var'))
+    blabels = [it.label for it in bare]
+    assrt.ok(blabels.indexOf('run') >= 0, 'completion should include the top-level function run')
+    assrt.ok(blabels.indexOf('print') >= 0, 'completion should include builtins')
+    fs.rmSync(tmp, {'recursive': True})
+
+async def test_formatting():
+    ctx = lsp.create_server_context({'line_length': 80, 'preferred_quote': 'single'})
+    edits = lsp.format_document(ctx, 'x=1;y=2\n')
+    assrt.equal(edits.length, 1, 'formatting a mis-spaced document should yield one edit')
+    assrt.equal(edits[0].newText, 'x = 1; y = 2\n', 'formatter should normalize spacing')
+    # An already-formatted document yields no edits.
+    assrt.equal(lsp.format_document(ctx, 'x = 1\n').length, 0, 'well formatted input needs no edits')
+
+async def test_error_recovery_still_analyzes():
+    tmp = write_workspace()
+    ctx = make_ctx(tmp)
+    uri = uri_of(path.join(tmp, 'broke.pyj'))
+    # alpha() has a syntax error but beta() must still be analyzable.
+    text = 'def alpha():\n    x = \n    return x\n\ndef beta():\n    y = 1\n    return y + y\n'
+    diags = await lsp.compute_diagnostics(ctx, uri, text)
+    assrt.ok(codes(diags)['syntax-err'], 'a syntax error should be reported')
+    off = offset_of(text, 'return y + y') + 'return '.length
+    h = await lsp.hover(ctx, uri, text, off)
+    assrt.ok(h and h.contents.value.indexOf('y') >= 0, 'hover must work in the healthy part of a broken file')
+    fs.rmSync(tmp, {'recursive': True})
+
+async def test_parser_recovery_flag():
+    # The recover_errors parser option must never regress the normal path: a
+    # broken file throws without it and yields recovered_errors with it.
+    code = 'def good():\n    return 1\n\ndef bad(:\n    pass\n\nx = 2\n'
+    threw = False
+    try:
+        await RapydScript.parse(code, {'filename': 'r.pyj', 'basedir': test_path, 'libdir': libdir, 'for_linting': True})
+    except:
+        threw = True
+    assrt.ok(threw, 'normal parse must still throw on syntax errors (no regression)')
+
+    top = await RapydScript.parse(code, {'filename': 'r.pyj', 'basedir': test_path, 'libdir': libdir, 'for_linting': True, 'recover_errors': True})
+    assrt.ok(top, 'recover_errors parse should return a toplevel')
+    assrt.ok(top.recovered_errors and top.recovered_errors.length >= 1, 'recovered_errors should be populated')
+
+async def test_configuration_change():
+    ctx = lsp.create_server_context({'line_length': 80, 'preferred_quote': 'single', 'import_dirs': []})
+
+    # Basic updates.
+    lsp.apply_configuration(ctx, {'lineLength': 120, 'preferredQuote': 'double', 'importPath': '/tmp/mylibs'})
+    assrt.equal(ctx.line_length, 120, 'lineLength should update line_length')
+    assrt.equal(ctx.preferred_quote, 'double', 'preferredQuote should update preferred_quote')
+    assrt.ok(ctx.import_dirs.length > 0, 'string importPath should populate import_dirs')
+
+    # Array-form importPath.
+    lsp.apply_configuration(ctx, {'importPath': ['/tmp/lib1', '/tmp/lib2']})
+    assrt.equal(ctx.import_dirs.length, 2, 'array importPath should yield 2 entries')
+
+    # Invalid values must be silently ignored.
+    lsp.apply_configuration(ctx, {'lineLength': 'bogus', 'preferredQuote': 'wrong'})
+    assrt.equal(ctx.line_length, 120, 'bogus lineLength must be ignored')
+    assrt.equal(ctx.preferred_quote, 'double', 'invalid preferredQuote must be ignored')
+
+    # Empty/absent settings must be a no-op.
+    lsp.apply_configuration(ctx, {})
+    assrt.equal(ctx.line_length, 120, 'empty settings must not reset line_length')
+
+    # Numeric lineLength (number type, not string).
+    lsp.apply_configuration(ctx, {'lineLength': 100})
+    assrt.equal(ctx.line_length, 100, 'numeric lineLength should be accepted')
+
+    # Empty importPath string clears the dirs.
+    lsp.apply_configuration(ctx, {'importPath': ''})
+    assrt.equal(ctx.import_dirs.length, 0, 'empty importPath string should clear import_dirs')
+
+async def run_tests():
+    await test_diagnostics()
+    await test_hover_and_definition()
+    await test_cross_file_references()
+    await test_cross_file_rename()
+    await test_invalid_rename()
+    await test_local_rename()
+    await test_completion()
+    await test_formatting()
+    await test_error_recovery_still_analyzes()
+    await test_parser_recovery_flag()
+    await test_configuration_change()
+
+__test_async_done__ = run_tests()

package/test/repl.pyj

@@ -1,4 +1,4 @@
-# globals: compiler_dir
+# globals: compiler_dir, rs_repl
 stdout = []
 def clear():
     stdout.length = 0
@@ -40,48 +40,49 @@ class FakeReadline:
         stdout.push(self._prompt)
 
     def send_line(self, text):
-        self.listeners['line'](text)
+        return self.listeners['line'](text)
 
-repl = require('./repl')
+repl = rs_repl
 rl = FakeReadline()
 
-send_line = rl.send_line.bind(rl)
-
-def send_text(text):
-    for line in text.split('\n'):
-        send_line(line)
-
-def check(text, output):
-    send_text(text)
-    eq(output, stdout[0])
-    clear()
-
-def check_in(text, output):
-    send_text(text)
-    assrt.ok(output in stdout, output + ' not in ' + stdout)
-    clear()
-
-def check_not_in(text, output):
-    send_text(text)
-    assrt.ok(output not in stdout)
-    clear()
-
 readline = {
     'createInterface': def(options):
         rl.completer = options.completer
         return rl
 }
-repl({'lib_path':compiler_dir, 'console':FakeConsole(), 'readline':readline, 'terminal':False, 'show_js':False, 'histfile':False})
-eq = assrt.equal
-eq('>>> ', stdout[-1])
-clear()
-check('1', '1')
-check_in('if 1:\n  2\n  \n  ', '2')
-check_not_in('if 1:\n  2\n ', '2')
-check_in('1 +\n1\n\n', '2')
-check('max(1, 2)', '2')
-send_text(
-'''
+
+async def run_tests():
+    await repl({'lib_path':compiler_dir, 'console':FakeConsole(), 'readline':readline, 'terminal':False, 'show_js':False, 'histfile':False})
+    eq = assrt.equal
+
+    async def send_text(text):
+        for line in text.split('\n'):
+            await rl.send_line(line)
+
+    async def check(text, output):
+        await send_text(text)
+        eq(output, stdout[0])
+        clear()
+
+    async def check_in(text, output):
+        await send_text(text)
+        assrt.ok(output in stdout, output + ' not in ' + stdout)
+        clear()
+
+    async def check_not_in(text, output):
+        await send_text(text)
+        assrt.ok(output not in stdout)
+        clear()
+
+    eq('>>> ', stdout[-1])
+    clear()
+    await check('1', '1')
+    await check_in('if 1:\n  2\n  \n  ', '2')
+    await check_not_in('if 1:\n  2\n ', '2')
+    await check_in('1 +\n1\n\n', '2')
+    await check('max(1, 2)', '2')
+    await send_text(
+    '''
 class A:
 
     def __init__(self, a):
@@ -89,33 +90,37 @@ class A:
 
 
 ''')
-clear()
-check_in('b = A(1)\nb.a', '1')
-check_in('c = A(2)\nc.a', '2')
-send_text('from __python__ import dict_literals\nd={1:1}')
-check_in('isinstance(d, dict)', 'true')
-send_text('from __python__ import no_dict_literals\nd={1:1}')
-check_in('isinstance(d, dict)', 'false')
-# Test completions
-def completions(line):
-    return rl.completer(line)[0]
-
-def check_completions():
-    items = completions(arguments[0])
-    for x in Array.prototype.slice.call(arguments, 1):
-        assrt.ok(items and x in items, x + ' not in completions for: ' + arguments[0])
-
-check_completions('', 'return', 'A')
-check_completions('Array.', 'isArray', 'apply')
-send_text('x = ""\ny = []'), clear()
-check_completions('x.', 'substr', 'trim')
-check_completions('y.', 'concat', 'push')
-check_completions('x.sl', 'slice')
-send_text('y = {"x":1}'), clear()
-check_completions('y.', 'x')
-
-# Test docstrings
-clear()
-send_text('def ds():\n "xxx"\n\n')
-clear()
-check('ds.__doc__', "'xxx'")
+    clear()
+    await check_in('b = A(1)\nb.a', '1')
+    await check_in('c = A(2)\nc.a', '2')
+    await send_text('from __python__ import dict_literals\nd={1:1}')
+    await check_in('isinstance(d, dict)', 'true')
+    await send_text('from __python__ import no_dict_literals\nd={1:1}')
+    await check_in('isinstance(d, dict)', 'false')
+    # Test completions
+    def completions(line):
+        return rl.completer(line)[0]
+
+    def check_completions():
+        items = completions(arguments[0])
+        for x in Array.prototype.slice.call(arguments, 1):
+            assrt.ok(items and x in items, x + ' not in completions for: ' + arguments[0])
+
+    check_completions('', 'return', 'A')
+    check_completions('Array.', 'isArray', 'apply')
+    await send_text('x = ""\ny = []')
+    clear()
+    check_completions('x.', 'substr', 'trim')
+    check_completions('y.', 'concat', 'push')
+    check_completions('x.sl', 'slice')
+    await send_text('y = {"x":1}')
+    clear()
+    check_completions('y.', 'x')
+
+    # Test docstrings
+    clear()
+    await send_text('def ds():\n "xxx"\n\n')
+    clear()
+    await check('ds.__doc__', "'xxx'")
+
+__test_async_done__ = run_tests()