kapusta 0.9.0 → 0.11.0

data/lib/kapusta/errors.rb

@@ -10,6 +10,7 @@ module Kapusta
       bad_set_target: 'bad set target: %{target}',
       bad_shorthand: 'bad shorthand',
       bind_table_dots: 'unable to bind table ...',
+      cannot_call_constant: 'cannot call constant %{name}; reference it without parentheses',
       cannot_call_literal: 'cannot call literal value %{value}',
       cannot_emit_form: 'cannot emit form: %{form}',
       cannot_set_method_binding: 'cannot set method binding: %{name}',
@@ -24,6 +25,9 @@ module Kapusta
       dot_no_args: 'expected table argument',
       each_no_binding: 'expected binding table',
       empty_call: 'expected a function, macro, or special to call',
+      end_outside_header: 'end outside class or module',
+      end_with_args: 'end takes no arguments',
+      unclosed_header: 'class or module not closed with (end)',
       expected_var: 'expected var %{name}',
       fn_no_params: 'expected parameters table',
       global_arity: 'expected name and value',
@@ -51,6 +55,7 @@ module Kapusta
       odd_forms_in_hash: 'odd number of forms in hash',
       rest_not_last: 'expected rest argument before last parameter',
       shadowed_special: 'local %{name} was overshadowed by a special form or macro',
+      target_requires_compile: '--target requires --compile',
       tset_no_value: 'tset: expected table, key, and value arguments',
       unclosed_delimiter: "unclosed opening delimiter '%{char}'",
       undefined_symbol: 'undefined symbol: %{name}',
@@ -58,6 +63,7 @@ module Kapusta
       unexpected_eof: 'unexpected eof',
       unexpected_vararg: 'unexpected vararg',
       unknown_special_form: 'unknown special form: %{name}',
+      unknown_target: 'unknown target %{target}; only mruby is supported',
       unquote_outside_quasiquote: 'unquote outside quasiquote',
       unquote_splice_outside_list: 'unquote-splice must appear inside a quoted list/vec',
       unterminated_string: 'unterminated string',

data/lib/kapusta/formatter.rb

@@ -266,7 +266,7 @@ module Kapusta
       raw_args = list_raw_rest(list)
 
       case head_name
-      when 'fn', 'lambda', 'λ', 'macro' then render_fn(head_name, list, indent, top_level:)
+      when 'fn', 'defn', 'lambda', 'λ', 'macro' then render_fn(head_name, list, indent, top_level:)
       when 'let' then render_let(list, indent)
       when 'do', 'finally' then render_prefix_body_form(head_name, [], raw_args, indent)
       when 'try' then render_try(list, indent)
@@ -657,7 +657,6 @@ module Kapusta
 
     def render_let_bindings(bindings, indent)
       return render(bindings, indent + '(let '.length, force_expand: true) if contains_comments?(bindings.items)
-      return render(bindings, indent + '(let '.length, layout: :pairwise) if bindings.items.length <= 2
 
       hanging = render_hanging_pairwise_vec(bindings)
       hanging || render(bindings, indent + '(let '.length, layout: :pairwise)

data/lib/kapusta/lsp/definition.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 require_relative 'rename'
+require_relative '../reader'
+require_relative 'scope_walker'
 
 module Kapusta
   class LSP
@@ -8,6 +10,9 @@ module Kapusta
       module_function
 
       def find(uri, text, line_zero, character, workspace_index:)
+        marker = end_marker_at(text, line_zero, character)
+        return location_for_binding(uri, marker.target) if marker&.target
+
         target = Rename.locate(text, line_zero, character)
         return unless target
 
@@ -23,6 +28,18 @@ module Kapusta
         end
       end
 
+      def end_marker_at(text, line_zero, character)
+        forms = Reader.read_all(text)
+        walker = ScopeWalker.analyze(forms)
+        line = line_zero + 1
+        col = character + 1
+        walker.end_markers.find do |m|
+          m.line == line && col >= m.column && col <= m.end_column
+        end
+      rescue Kapusta::Error
+        nil
+      end
+
       def locations_for_macro(uri, binding, workspace_index)
         return unless binding
 

data/lib/kapusta/lsp/rename.rb

@@ -344,7 +344,9 @@ module Kapusta
       end
 
       def rename_constant(target, new_name, workspace_index)
-        return error("invalid constant segment: #{new_name}") unless Identifier.valid_constant_segment?(new_name)
+        unless Identifier.valid_constant_segment?(new_name)
+          return error("class and module names must start with an uppercase letter (got #{new_name.inspect})")
+        end
 
         prefix = target.segment_prefix
         seg_index = target.segment_index

data/lib/kapusta/lsp/scope_walker.rb

@@ -15,6 +15,7 @@ module Kapusta
           bindings[name] || parent&.lookup(name)
         end
       end
+      EndMarker = Struct.new(:line, :column, :end_column, :target, keyword_init: true)
 
       SKIPPED_HEADS = %w[macros quasi-sym quasi-list
                          quasi-list-tail quasi-vec quasi-vec-tail quasi-hash quasi-gensym].freeze
@@ -26,6 +27,7 @@ module Kapusta
         'global' => :walk_global,
         'set' => :walk_set,
         'fn' => :walk_fn,
+        'defn' => :walk_fn,
         'lambda' => :walk_fn,
         'λ' => :walk_fn,
         'for' => :walk_for,
@@ -48,7 +50,7 @@ module Kapusta
         'gvar' => :walk_sigil_form
       }.freeze
 
-      attr_reader :bindings, :references, :root_scope
+      attr_reader :bindings, :references, :root_scope, :end_markers
 
       def self.analyze(forms)
         walker = new
@@ -59,6 +61,7 @@ module Kapusta
       def initialize
         @bindings = []
         @references = []
+        @end_markers = []
         @scope_seq = 0
         @root_scope = make_scope(nil, :file)
         @gvar_scope = make_scope(nil, :gvars)
@@ -67,17 +70,43 @@ module Kapusta
       end
 
       def walk_top(forms)
-        i = 0
+        walk_form_run(forms, 0, @root_scope)
+      end
+
+      def walk_form_run(forms, start, scope, header_target: nil)
+        i = start
         while i < forms.length
           form = forms[i]
+          if end_form?(form)
+            record_end_marker(form, header_target) if header_target
+            return i + 1
+          end
+
           if bodyless_header?(form)
-            walk_bodyless_header(form, forms[(i + 1)..] || [], @root_scope)
-            break
+            i = walk_bodyless_header(form, forms, i + 1, scope)
+            next
           end
 
-          walk_form(form, @root_scope)
+          walk_form(form, scope)
           i += 1
         end
+        i
+      end
+
+      def record_end_marker(form, target)
+        head = form.head
+        return unless head.is_a?(Sym) && head.respond_to?(:line) && head.line
+
+        @end_markers << EndMarker.new(
+          line: head.line,
+          column: head.column,
+          end_column: head.column + head.name.length,
+          target:
+        )
+      end
+
+      def end_form?(form)
+        form.is_a?(List) && !form.empty? && form.head.is_a?(Sym) && form.head.name == 'end'
       end
 
       def binding_at(line, column)
@@ -120,25 +149,25 @@ module Kapusta
         end
       end
 
-      def walk_bodyless_header(form, remaining_forms, scope)
+      def walk_bodyless_header(form, forms, body_start, scope)
         case form.head.name
         when 'module'
           name_sym = form.items[1]
-          add_constant_binding(name_sym, scope, :module) if name_sym.is_a?(Sym)
+          binding = name_sym.is_a?(Sym) ? add_constant_binding(name_sym, scope, :module) : nil
           body = form.items[2..] || []
           inside_module_or_class do
             if body.length == 1 && bodyless_header?(body[0])
-              walk_bodyless_header(body[0], remaining_forms, scope)
+              walk_bodyless_header(body[0], forms, body_start, scope)
             else
-              remaining_forms.each { |item| walk_form(item, scope) }
+              walk_form_run(forms, body_start, scope, header_target: binding)
             end
           end
         when 'class'
           name_sym, supers, = split_class_args(form.items[1..] || [])
           supers&.items&.each { |item| walk_form(item, scope) }
-          add_constant_binding(name_sym, scope, :class) if name_sym.is_a?(Sym)
+          binding = name_sym.is_a?(Sym) ? add_constant_binding(name_sym, scope, :class) : nil
           inside_class do
-            remaining_forms.each { |item| walk_form(item, scope) }
+            walk_form_run(forms, body_start, scope, header_target: binding)
           end
         end
       end

data/lib/kapusta/lsp.rb

@@ -257,7 +257,8 @@ module Kapusta
                               new_name, workspace_index: @workspace_index)
       if result[:error]
         debug("rename error: #{result[:error].inspect}")
-        reply_error(id, result[:error][:code], result[:error][:message])
+        notify('window/showMessage', { type: 1, message: "Rename: #{result[:error][:message]}" })
+        reply(id, { documentChanges: [] })
       else
         edit = build_workspace_edit(result[:changes])
         debug("rename ok: files=#{result[:changes].keys.length} edits=#{result[:changes].values.sum(&:length)}")

data/lib/kapusta/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Kapusta
-  VERSION = '0.9.0'
+  VERSION = '0.11.0'
 end

data/lib/kapusta.rb

@@ -23,8 +23,8 @@ module Kapusta
     self.eval(source, path:)
   end
 
-  def self.compile(source, path: '(eval)', **_opts)
-    Compiler.compile(source, path:)
+  def self.compile(source, path: '(eval)', target: nil, **_opts)
+    Compiler.compile(source, path:, target:)
   end
 
   def self.require(feature, relative_to: nil)

data/spec/cli_spec.rb

@@ -66,6 +66,19 @@ RSpec.describe Kapusta::CLI do
     end
   end
 
+  it 'compiles case and match forms for mruby with --target=mruby' do
+    path = File.expand_path('../examples/match.kap', __dir__)
+
+    ruby = capture_stdout do
+      described_class.start(['--compile', '--target=mruby', path])
+    end
+
+    expect(ruby).not_to match(/^\s*in\b/)
+    expect(ruby).not_to include('^(')
+    expect(ruby).to include("case\n")
+    expect(ruby).to include('when ')
+  end
+
   it 'rejects extra positional arguments in compile mode' do
     path = File.expand_path('../examples/fizzbuzz.kap', __dir__)
 
@@ -77,6 +90,28 @@ RSpec.describe Kapusta::CLI do
     expect(error_output).to include('usage: kapusta')
   end
 
+  it 'rejects unsupported targets' do
+    path = File.expand_path('../examples/fizzbuzz.kap', __dir__)
+
+    error_output = capture_stderr do
+      expect { described_class.start(['--compile', '--target=mri', path]) }
+        .to raise_error(SystemExit)
+    end
+
+    expect(error_output).to include('unknown target "mri"; only mruby is supported')
+  end
+
+  it 'rejects target without compile mode' do
+    path = File.expand_path('../examples/fizzbuzz.kap', __dir__)
+
+    error_output = capture_stderr do
+      expect { described_class.start(['--target=mruby', path]) }
+        .to raise_error(SystemExit)
+    end
+
+    expect(error_output).to include('--target requires --compile')
+  end
+
   it 'passes remaining arguments through to the Kapusta program' do
     path = File.expand_path('../examples/greet.kap', __dir__)
 

data/spec/examples_errors_spec.rb

@@ -92,6 +92,26 @@ RSpec.describe 'examples-errors' do
       .to eq("destructure-literal-table.kap:4:1: could not destructure literal\n")
   end
 
+  it 'end-outside-header.kap' do
+    expect(run_error_example('end-outside-header.kap'))
+      .to eq("end-outside-header.kap:1:1: end outside class or module\n")
+  end
+
+  it 'end-with-args.kap' do
+    expect(run_error_example('end-with-args.kap'))
+      .to eq("end-with-args.kap:5:1: end takes no arguments\n")
+  end
+
+  it 'extra-end.kap' do
+    expect(run_error_example('extra-end.kap'))
+      .to eq("extra-end.kap:7:1: end outside class or module\n")
+  end
+
+  it 'unclosed-header.kap' do
+    expect(run_error_example('unclosed-header.kap'))
+      .to eq("unclosed-header.kap:1:1: class or module not closed with (end)\n")
+  end
+
   it 'destructure-rest-as-table.kap' do
     expect(run_error_example('destructure-rest-as-table.kap'))
       .to eq("destructure-rest-as-table.kap:6:3: unable to bind table ...\n")

data/spec/examples_spec.rb

@@ -2,10 +2,21 @@
 
 require 'spec_helper'
 require 'fileutils'
+require 'open3'
 require 'stringio'
+require 'tempfile'
 
 EXAMPLES_DIR = File.expand_path('../examples', __dir__)
 
+def example_list(name)
+  File.readlines(File.join(EXAMPLES_DIR, name), chomp: true)
+      .reject(&:empty?)
+      .map { |example| "#{example}.kap" }
+      .freeze
+end
+
+MRUBY_RUNTIME_EXAMPLES = example_list('mruby-runtime-examples.txt')
+
 def run_example(name, argv: [])
   previous_argv = ARGV.dup
   previous_stdout = $stdout
@@ -27,6 +38,39 @@ ensure
   $stdout = previous_stdout
 end
 
+def compile_example(name, target: nil)
+  path = File.join(EXAMPLES_DIR, name)
+  Kapusta.compile(File.read(path), path:, target:)
+end
+
+def run_compiled_source(source, path:)
+  previous_argv = ARGV.dup
+  previous_stdout = $stdout
+  ARGV.replace([])
+  $stdout = StringIO.new
+  TOPLEVEL_BINDING.eval(source, path, 1)
+  $stdout.string
+ensure
+  $stdout = previous_stdout
+  ARGV.replace(previous_argv)
+end
+
+def run_mruby_source(source, path:)
+  stdout, stderr, status = capture_mruby_source(source, path:)
+
+  raise "mruby failed for #{path}:\n#{stderr}" unless status.success?
+
+  stdout
+end
+
+def capture_mruby_source(source, path:)
+  Tempfile.create([File.basename(path, '.kap'), '.rb']) do |file|
+    file.write(source)
+    file.close
+    Open3.capture3('mruby', file.path)
+  end
+end
+
 RSpec.describe 'examples' do
   it 'ackermann.kap' do
     expect(run_example('ackermann.kap')).to eq("9\n61\n")
@@ -36,6 +80,18 @@ RSpec.describe 'examples' do
     expect(run_example('accumulator.kap')).to eq("22\n")
   end
 
+  it 'account-lockout.kap' do
+    expect(run_example('account-lockout.kap')).to eq(<<~OUT)
+      :ok
+      :locked
+      :locked
+    OUT
+  end
+
+  it 'circle.kap' do
+    expect(run_example('circle.kap')).to eq("78.53975\n31.4159\n")
+  end
+
   it 'anagram.kap' do
     expect(run_example('anagram.kap')).to eq("true\ntrue\nfalse\n")
   end
@@ -107,6 +163,26 @@ RSpec.describe 'examples' do
     expect(run_example('happy-number.kap')).to eq("true\nfalse\ntrue\n")
   end
 
+  it 'number-of-1-bits.kap' do
+    expect(run_example('number-of-1-bits.kap')).to eq("3\n1\n31\n")
+  end
+
+  it 'number-of-steps.kap' do
+    expect(run_example('number-of-steps.kap')).to eq("6\n4\n12\n")
+  end
+
+  it 'convert-temperature.kap' do
+    expect(run_example('convert-temperature.kap')).to eq("309.65\n97.7\n395.26\n251.798\n")
+  end
+
+  it 'count-effects.kap' do
+    expect(run_example('count-effects.kap')).to eq("1\n2\n")
+  end
+
+  it 'max-achievable.kap' do
+    expect(run_example('max-achievable.kap')).to eq("6\n7\n10\n")
+  end
+
   it 'move-zeroes.kap' do
     expect(run_example('move-zeroes.kap')).to eq(<<~OUT)
       [1, 3, 12, 0, 0]
@@ -368,6 +444,18 @@ RSpec.describe 'examples' do
     OUT
   end
 
+  it 'underscore-patterns.kap on mruby keeps loose nil and strict fallback separate' do
+    path = File.join(EXAMPLES_DIR, 'underscore-patterns.kap')
+    ruby = compile_example('underscore-patterns.kap', target: :mruby)
+
+    expect(run_mruby_source(ruby, path:)).to eq(<<~OUT)
+      5
+      nil
+      5
+      "fallback"
+    OUT
+  end
+
   it 'scopes.kap' do
     expect(run_example('scopes.kap')).to eq("5\n9\n9\n9\n")
   end
@@ -399,6 +487,10 @@ RSpec.describe 'examples' do
     OUT
   end
 
+  it 'signal-harvest.kap' do
+    expect(run_example('signal-harvest.kap')).to eq("40\ntrue\nfalse\n")
+  end
+
   it 'shapes.kap' do
     expect(run_example('shapes.kap')).to eq("78.5\n9\n8\n0\n")
   end
@@ -437,6 +529,19 @@ RSpec.describe 'examples' do
     expect(run_example('two-sum-hash.kap')).to eq("[0, 1]\n[1, 2]\nnil\n")
   end
 
+  it 'bst-iterator.kap' do
+    expect(run_example('bst-iterator.kap')).to eq(<<~OUT)
+      3
+      7
+      true
+      9
+      true
+      15
+      20
+      false
+    OUT
+  end
+
   it 'baseball-game.kap' do
     expect(run_example('baseball-game.kap')).to eq("30\n27\n")
   end
@@ -468,6 +573,10 @@ RSpec.describe 'examples' do
     OUT
   end
 
+  it 'recent-counter.kap' do
+    expect(run_example('recent-counter.kap')).to eq("4\n5\n")
+  end
+
   it 'reverse-integer.kap' do
     expect(run_example('reverse-integer.kap')).to eq("321\n-321\n21\n0\n")
   end
@@ -577,3 +686,30 @@ RSpec.describe 'examples' do
     OUT
   end
 end
+
+RSpec.describe 'mruby runtime examples' do
+  MRUBY_RUNTIME_EXAMPLES.each do |name|
+    it name do
+      path = File.join(EXAMPLES_DIR, name)
+      ruby = compile_example(name)
+      expected = run_example(name)
+      expect(run_compiled_source(ruby, path:)).to eq(expected)
+      mruby_stdout, _mruby_stderr, mruby_status = capture_mruby_source(ruby, path:)
+
+      if mruby_status.success? && mruby_stdout == expected
+        expect(run_mruby_source(ruby, path:)).to eq(expected)
+      else
+        mruby_ruby = compile_example(name, target: :mruby)
+
+        if mruby_ruby == ruby
+          expect(mruby_status).to be_success
+        else
+          expect(mruby_ruby).not_to match(/^\s*in\b/)
+          expect(mruby_ruby).not_to include('^(')
+          expect(run_compiled_source(mruby_ruby, path:)).to eq(expected)
+          run_mruby_source(mruby_ruby, path:)
+        end
+      end
+    end
+  end
+end

data/spec/lsp_spec.rb

@@ -268,7 +268,8 @@ RSpec.describe Kapusta::LSP do
         frame_rename(uri: uri['a.kap'], **cursor_at(text_a, 'foo'), new_name: 'bar')
       )
 
-      expect(result_for(responses).dig('error', 'message')).to include('already defined')
+      message = responses.find { |m| m['method'] == 'window/showMessage' }
+      expect(message['params']['message']).to include('already defined')
     end
   end
 
@@ -282,7 +283,8 @@ RSpec.describe Kapusta::LSP do
         frame_rename(uri: uri['a.kap'], **cursor_at(text_a, 'Foo'), new_name: 'Bar')
       )
 
-      expect(result_for(responses).dig('error', 'message')).to include('already defined')
+      message = responses.find { |m| m['method'] == 'window/showMessage' }
+      expect(message['params']['message']).to include('already defined')
     end
   end
 
@@ -304,6 +306,71 @@ RSpec.describe Kapusta::LSP do
     )
   end
 
+  it 'rejects renaming a class to a lowercase name with a clear message' do
+    text = "(class Accumulator)\n\n(end)\n"
+    responses = run(
+      frame_initialize,
+      frame_did_open('file:///x.kap', text),
+      frame_rename(uri: 'file:///x.kap', **cursor_at(text, 'Accumulator'), new_name: 'fff')
+    )
+
+    response = result_for(responses)
+    expect(response['error']).to be_nil
+    expect(response['result']).to eq('documentChanges' => [])
+
+    show_message = responses.find { |m| m['method'] == 'window/showMessage' }
+    expect(show_message).not_to be_nil
+    expect(show_message['params']['type']).to eq(1)
+    expect(show_message['params']['message']).to include('uppercase letter')
+  end
+
+  it 'renames a class declared with a bodyless header closed by (end) and its usages after (end)' do
+    text = "(class Accumulator)\n\n(fn add! [n] n)\n\n(end)\n\n(let [acc (Accumulator.new 10)]\n  (acc.add! 5))\n"
+    with_workspace('a.kap' => text) do |root_uri, uri|
+      responses = run(
+        frame_initialize([root_uri]),
+        frame_did_open(uri['a.kap'], text),
+        frame_rename(uri: uri['a.kap'], **cursor_at(text, 'Accumulator'), new_name: 'Foo')
+      )
+      result = result_for(responses)['result']
+
+      expect(result).not_to be_nil
+      edits = result['documentChanges'].first['edits']
+      expect(edits.map { |e| e['range']['start']['line'] }).to contain_exactly(0, 6)
+      expect(edits.map { |e| e['newText'] }).to all(eq('Foo'))
+    end
+  end
+
+  it 'jumps from (end) to the class header that opened the file scope' do
+    text = "(class Foo)\n\n(fn hi [] 1)\n\n(end)\n"
+    responses = run(
+      frame_initialize,
+      frame_did_open('file:///x.kap', text),
+      frame_definition(uri: 'file:///x.kap', **cursor_at(text, 'end'))
+    )
+    result = result_for(responses)['result']
+
+    expect(result).to eq(
+      'uri' => 'file:///x.kap',
+      'range' => {
+        'start' => { 'line' => 0, 'character' => 7 },
+        'end' => { 'line' => 0, 'character' => 10 }
+      }
+    )
+  end
+
+  it 'jumps from (end) to the matching module header for nested headers' do
+    text = "(module Outer)\n\n(module Inner)\n(fn self.go [] 1)\n(end)\n\n(end)\n"
+    responses = run(
+      frame_initialize,
+      frame_did_open('file:///x.kap', text),
+      frame_definition(uri: 'file:///x.kap', line: 4, character: 1)
+    )
+    result = result_for(responses)['result']
+
+    expect(result['range']['start']).to eq('line' => 2, 'character' => 8)
+  end
+
   it 'jumps to a top-level fn definition across files' do
     text_a = "(fn greet [n] (print n))\n"
     text_b = "(greet 42)\n"
@@ -583,7 +650,8 @@ RSpec.describe Kapusta::LSP do
         frame_rename(uri: uri['a.kap'], **cursor_at(text_a, 'swap!'), new_name: 'flip!')
       )
 
-      expect(result_for(responses).dig('error', 'message')).to include('already defined')
+      message = responses.find { |m| m['method'] == 'window/showMessage' }
+      expect(message['params']['message']).to include('already defined')
     end
   end
 

data/spec/spec_helper.rb

@@ -3,6 +3,15 @@
 require 'bundler/setup'
 require 'kapusta'
 
+module SilenceConstantRedefinitionWarnings
+  def warn(message, category: nil)
+    return if /already initialized constant|previous definition of/.match?(message)
+
+    super
+  end
+end
+Warning.singleton_class.prepend(SilenceConstantRedefinitionWarnings)
+
 RSpec.configure do |config|
   config.disable_monkey_patching!
   config.example_status_persistence_file_path = '.rspec_status'