kapusta 0.5.0 → 0.7.0

data/spec/examples_errors_spec.rb

@@ -27,6 +27,26 @@ RSpec.describe 'examples-errors' do
       .to eq("accumulate-missing-iterator.kap:5:3: expected initial value and iterator binding table\n")
   end
 
+  it 'auto-gensym-outside-quasiquote.kap' do
+    expect(run_error_example('auto-gensym-outside-quasiquote.kap'))
+      .to eq("auto-gensym-outside-quasiquote.kap: auto-gensym x# outside quasiquote\n")
+  end
+
+  it 'bad-multisym.kap' do
+    expect(run_error_example('bad-multisym.kap'))
+      .to eq("bad-multisym.kap:1:8: bad multisym: unbound.foo\n")
+  end
+
+  it 'bad-set-target.kap' do
+    expect(run_error_example('bad-set-target.kap'))
+      .to eq("bad-set-target.kap:2:1: bad set target: 1\n")
+  end
+
+  it 'bad-shorthand.kap' do
+    expect(run_error_example('bad-shorthand.kap'))
+      .to eq("bad-shorthand.kap:2:14: bad shorthand\n")
+  end
+
   it 'call-empty-form.kap' do
     expect(run_error_example('call-empty-form.kap'))
       .to eq("call-empty-form.kap:7:8: expected a function, macro, or special to call\n")
@@ -37,16 +57,31 @@ RSpec.describe 'examples-errors' do
       .to eq("call-literal-number.kap:6:14: cannot call literal value 1\n")
   end
 
+  it 'cannot-set-method-binding.kap' do
+    expect(run_error_example('cannot-set-method-binding.kap'))
+      .to eq("cannot-set-method-binding.kap:2:1: cannot set method binding: foo\n")
+  end
+
   it 'case-no-patterns.kap' do
     expect(run_error_example('case-no-patterns.kap'))
       .to eq("case-no-patterns.kap:3:5: expected at least one pattern/body pair\n")
   end
 
+  it 'case-no-subject.kap' do
+    expect(run_error_example('case-no-subject.kap'))
+      .to eq("case-no-subject.kap:1:1: missing subject\n")
+  end
+
   it 'case-odd-pattern-body.kap' do
     expect(run_error_example('case-odd-pattern-body.kap'))
       .to eq("case-odd-pattern-body.kap:2:3: expected even number of pattern/body pairs\n")
   end
 
+  it 'case-unsupported.kap' do
+    expect(run_error_example('case-unsupported.kap'))
+      .to eq("case-unsupported.kap:1:1: case/match clauses use patterns this compiler cannot translate\n")
+  end
+
   it 'destructure-literal-number.kap' do
     expect(run_error_example('destructure-literal-number.kap'))
       .to eq("destructure-literal-number.kap:5:3: could not destructure literal\n")
@@ -122,6 +157,16 @@ RSpec.describe 'examples-errors' do
       .to eq("import-macros-missing-module.kap:4:1: import-macros is not yet supported\n")
   end
 
+  it 'invalid-class-name.kap' do
+    expect(run_error_example('invalid-class-name.kap'))
+      .to eq("invalid-class-name.kap: invalid class name: lowercase\n")
+  end
+
+  it 'invalid-module-name.kap' do
+    expect(run_error_example('invalid-module-name.kap'))
+      .to eq("invalid-module-name.kap: invalid module name: lowercase\n")
+  end
+
   it 'let-odd-bindings.kap' do
     expect(run_error_example('let-odd-bindings.kap'))
       .to eq("let-odd-bindings.kap:2:3: expected even number of name/value bindings\n")
@@ -142,6 +187,16 @@ RSpec.describe 'examples-errors' do
       .to eq("local-without-value.kap:6:3: local: expected name and value\n")
   end
 
+  it 'macro-name-must-be-symbol.kap' do
+    expect(run_error_example('macro-name-must-be-symbol.kap'))
+      .to eq("macro-name-must-be-symbol.kap: macro name must be a symbol\n")
+  end
+
+  it 'macro-params-must-be-vector.kap' do
+    expect(run_error_example('macro-params-must-be-vector.kap'))
+      .to eq("macro-params-must-be-vector.kap:1:12: macro params must be a vector\n")
+  end
+
   it 'macro-unsafe-bind.kap' do
     expect(run_error_example('macro-unsafe-bind.kap'))
       .to eq("macro-unsafe-bind.kap:13:8: macro tried to bind unsafe without gensym\n")
@@ -152,16 +207,46 @@ RSpec.describe 'examples-errors' do
       .to eq("macro-vararg-with-operator.kap:5:3: tried to use vararg with operator\n")
   end
 
+  it 'macros-entry-must-be-fn.kap' do
+    expect(run_error_example('macros-entry-must-be-fn.kap'))
+      .to eq("macros-entry-must-be-fn.kap: macros entry value must be a fn form, got 1\n")
+  end
+
+  it 'macros-entry-params-must-be-vector.kap' do
+    expect(run_error_example('macros-entry-params-must-be-vector.kap'))
+      .to eq("macros-entry-params-must-be-vector.kap:1:19: macros entry params must be a vector\n")
+  end
+
+  it 'macros-expects-hash.kap' do
+    expect(run_error_example('macros-expects-hash.kap'))
+      .to eq("macros-expects-hash.kap: macros expects a hash literal\n")
+  end
+
   it 'match-no-patterns.kap' do
     expect(run_error_example('match-no-patterns.kap'))
       .to eq("match-no-patterns.kap:3:5: expected at least one pattern/body pair\n")
   end
 
+  it 'match-no-subject.kap' do
+    expect(run_error_example('match-no-subject.kap'))
+      .to eq("match-no-subject.kap:1:1: missing subject\n")
+  end
+
   it 'mismatched-brackets.kap' do
     expect(run_error_example('mismatched-brackets.kap'))
       .to eq("mismatched-brackets.kap:4:19: unexpected closing delimiter ')'\n")
   end
 
+  it 'nested-quasiquote.kap' do
+    expect(run_error_example('nested-quasiquote.kap'))
+      .to eq("nested-quasiquote.kap: nested quasiquote is not supported\n")
+  end
+
+  it 'odd-forms-in-hash.kap' do
+    expect(run_error_example('odd-forms-in-hash.kap'))
+      .to eq("odd-forms-in-hash.kap:1:9: odd number of forms in hash\n")
+  end
+
   it 'only-rest-param.kap' do
     expect(run_error_example('only-rest-param.kap'))
       .to eq("only-rest-param.kap:4:1: expected rest argument before last parameter\n")
@@ -177,6 +262,11 @@ RSpec.describe 'examples-errors' do
       .to eq("rest-not-last.kap:6:3: expected rest argument before last parameter\n")
   end
 
+  it 'set-immutable-let.kap' do
+    expect(run_error_example('set-immutable-let.kap'))
+      .to eq("set-immutable-let.kap:2:3: expected var counter\n")
+  end
+
   it 'set-immutable-local.kap' do
     expect(run_error_example('set-immutable-local.kap'))
       .to eq("set-immutable-local.kap:8:3: expected var counter\n")
@@ -212,11 +302,46 @@ RSpec.describe 'examples-errors' do
       .to eq("unclosed-table.kap:4:21: unexpected closing delimiter ']'\n")
   end
 
+  it 'undefined-symbol.kap' do
+    expect(run_error_example('undefined-symbol.kap'))
+      .to eq("undefined-symbol.kap:1:8: undefined symbol: missing-symbol\n")
+  end
+
+  it 'unexpected-eof.kap' do
+    expect(run_error_example('unexpected-eof.kap'))
+      .to eq("unexpected-eof.kap:1:2: unexpected eof\n")
+  end
+
+  it 'unexpected-vararg.kap' do
+    expect(run_error_example('unexpected-vararg.kap'))
+      .to eq("unexpected-vararg.kap:2:10: unexpected vararg\n")
+  end
+
+  it 'unknown-special-form.kap' do
+    expect(run_error_example('unknown-special-form.kap'))
+      .to eq("unknown-special-form.kap:1:1: unknown special form: catch\n")
+  end
+
   it 'unquote-outside-quote.kap' do
     expect(run_error_example('unquote-outside-quote.kap'))
       .to eq("unquote-outside-quote.kap:5:10: cannot emit form: ,x\n")
   end
 
+  it 'unquote-splice-outside-list.kap' do
+    expect(run_error_example('unquote-splice-outside-list.kap'))
+      .to eq("unquote-splice-outside-list.kap: unquote-splice must appear inside a quoted list/vec\n")
+  end
+
+  it 'unterminated-string.kap' do
+    expect(run_error_example('unterminated-string.kap'))
+      .to eq("unterminated-string.kap:1:8: unterminated string\n")
+  end
+
+  it 'vararg-not-last.kap' do
+    expect(run_error_example('vararg-not-last.kap'))
+      .to eq("vararg-not-last.kap:1:1: expected vararg as last parameter\n")
+  end
+
   it 'var-without-value.kap' do
     expect(run_error_example('var-without-value.kap'))
       .to eq("var-without-value.kap:6:3: var: expected name and value\n")

data/spec/lsp_spec.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'kapusta/lsp'
+require 'json'
+require 'stringio'
+
+RSpec.describe Kapusta::LSP do
+  def frame(payload)
+    body = JSON.generate(payload)
+    "Content-Length: #{body.bytesize}\r\n\r\n#{body}"
+  end
+
+  def parse_responses(stdout)
+    messages = []
+    rest = stdout.dup
+    while (m = rest.match(/\AContent-Length: (\d+)\r\n\r\n/))
+      len = Integer(m[1], 10)
+      messages << JSON.parse(rest[m[0].length, len])
+      rest = rest[(m[0].length + len)..]
+    end
+    messages
+  end
+
+  def run(*frames)
+    input = StringIO.new(frames.join)
+    output = StringIO.new
+    log = StringIO.new
+    described_class.new(input:, output:, log:).run
+    parse_responses(output.string)
+  end
+
+  it 'advertises diagnostics and formatting capabilities on initialize' do
+    responses = run(frame(jsonrpc: '2.0', id: 1, method: 'initialize', params: {}))
+    capabilities = responses.first.dig('result', 'capabilities')
+
+    expect(capabilities).to include('textDocumentSync', 'documentFormattingProvider')
+  end
+
+  it 'publishes diagnostics for invalid source' do
+    responses = run(
+      frame(jsonrpc: '2.0', id: 1, method: 'initialize', params: {}),
+      frame(jsonrpc: '2.0', method: 'textDocument/didOpen',
+            params: { textDocument: { uri: 'file:///x.kap', version: 1, text: '(let [x 1] (+ x ()))' } })
+    )
+    diagnostics = responses.last.dig('params', 'diagnostics')
+
+    expect(diagnostics).not_to be_empty
+  end
+
+  it 'publishes no diagnostics for valid source' do
+    responses = run(
+      frame(jsonrpc: '2.0', id: 1, method: 'initialize', params: {}),
+      frame(jsonrpc: '2.0', method: 'textDocument/didOpen',
+            params: { textDocument: { uri: 'file:///x.kap', version: 1, text: '(print "hi")' } })
+    )
+
+    expect(responses.last.dig('params', 'diagnostics')).to be_empty
+  end
+
+  it 'returns a TextEdit for formatting' do
+    responses = run(
+      frame(jsonrpc: '2.0', id: 1, method: 'initialize', params: {}),
+      frame(jsonrpc: '2.0', method: 'textDocument/didOpen',
+            params: { textDocument: { uri: 'file:///x.kap', version: 1, text: "(fn  greet  [x]  (print  x))\n" } }),
+      frame(jsonrpc: '2.0', id: 2, method: 'textDocument/formatting',
+            params: { textDocument: { uri: 'file:///x.kap' } })
+    )
+    edits = responses.find { |m| m['id'] == 2 }['result']
+
+    expect(edits).to be_an(Array).and(be_one)
+    expect(edits.first).to include('range', 'newText')
+  end
+
+  it 'rejects requests sent before initialize' do
+    responses = run(
+      frame(jsonrpc: '2.0', id: 1, method: 'textDocument/formatting',
+            params: { textDocument: { uri: 'file:///x.kap' } })
+    )
+
+    expect(responses.first.dig('error', 'code')).to eq(-32_002)
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: kapusta
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.7.0
 platform: ruby
 authors:
 - Evgenii Morozov
@@ -13,6 +13,7 @@ description: Kapusta is a Lisp for the Ruby runtime.
 executables:
 - kapfmt
 - kapusta
+- kapusta-ls
 extensions: []
 extra_rdoc_files: []
 files:
@@ -37,6 +38,7 @@ files:
 - examples/block-sort.kap
 - examples/blocks-and-kwargs.kap
 - examples/calc.kap
+- examples/classify-wallet.kap
 - examples/climbing-stairs.kap
 - examples/contains-duplicate.kap
 - examples/counter.kap
@@ -80,6 +82,7 @@ files:
 - examples/pivot-index.kap
 - examples/plus-one.kap
 - examples/points.kap
+- examples/power-of-three.kap
 - examples/primes.kap
 - examples/raindrops.kap
 - examples/record.kap
@@ -109,6 +112,7 @@ files:
 - examples/zoo-animal-inheritance-2.kap
 - exe/kapfmt
 - exe/kapusta
+- exe/kapusta-ls
 - kapusta.gemspec
 - lib/kapusta.rb
 - lib/kapusta/ast.rb
@@ -122,12 +126,14 @@ files:
 - lib/kapusta/compiler/emitter/interop.rb
 - lib/kapusta/compiler/emitter/patterns.rb
 - lib/kapusta/compiler/emitter/support.rb
+- lib/kapusta/compiler/lua_compat.rb
 - lib/kapusta/compiler/macro_expander.rb
 - lib/kapusta/compiler/normalizer.rb
 - lib/kapusta/env.rb
 - lib/kapusta/error.rb
 - lib/kapusta/errors.rb
 - lib/kapusta/formatter.rb
+- lib/kapusta/lsp.rb
 - lib/kapusta/reader.rb
 - lib/kapusta/support.rb
 - lib/kapusta/version.rb
@@ -135,6 +141,7 @@ files:
 - spec/examples_errors_spec.rb
 - spec/examples_spec.rb
 - spec/formatter_spec.rb
+- spec/lsp_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/evmorov/kapusta
 licenses: