kapusta 0.11.1 → 0.12.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 85bcd0988a353fb851e5ff955c2b5196f39193e1c3c8fb6ca4a111d6260e774d
-  data.tar.gz: 80efbc138038947b866eaac96ef21d5cdccd04a461a25f2e17cbd7ce925ceaec
+  metadata.gz: d5e4a7dc8e3d044580b58064b4632706c2115964847d674c23bbe39a625e0b6e
+  data.tar.gz: b17a395b81ab568829022273e5df9ee5a186c052d6a1e4c843df631dfe1d6f76
 SHA512:
-  metadata.gz: 16d02e652b9221990ac027423e677a8f27c285d582c6bfb368f585140305e1c48dff5add4a8491a7996b5be99e34efd761e7fb280d8932fc6548622939b166b4
-  data.tar.gz: 8ab10f9991b7029d9366e47d434a9e9166568b870369f1fe585007fbe2cf9b750c84e8eb3b8fb015db255977eef80fd3255750fa99006d577a9564b640d84319
+  metadata.gz: d3e8ca629130a695a67a1c210ab06869518e2d232084e01a8cb6d180094e2b10b0cbc3f65c191a9a7a6b1e70727f1563f28e3637264cc7776a58c2e16e554991
+  data.tar.gz: 71695c0adf8e37705c9b9b85263e495578bcdd0d442c2d56ad09b1a6386640003164adf98d932c499472ae81d5c3d4a909898b907417e6d6463384b855b2fa33

data/README.md

@@ -2,11 +2,9 @@
 
 Kapusta is a Lisp for the Ruby runtime.
 
-It is inspired by [Fennel](https://fennel-lang.org). It is not intended to be production-ready like Clojure: that would be a lot of work, and Ruby is already a rich, elegant language.
+It is inspired by [Fennel](https://fennel-lang.org). Kapusta aims to bring the simplicity and joy of Lisp to Ruby. Where Fennel uses Lua's stdlib and runtime, Kapusta uses Ruby's.
 
-Instead, Kapusta aims to bring some of the simplicity and joy of Lisp to Ruby. Where Fennel uses Lua's stdlib and runtime, Kapusta uses Ruby's. You can use it for small apps, LeetCode, DragonRuby, or maybe even Rails.
-
-For more information about Kapusta, see the official Fennel documentation and tutorials.
+For more information about Kapusta, see the official Fennel documentation and tutorials, but replace Lua with Ruby.
 
 ## Features
 
@@ -41,14 +39,14 @@ exe/kapusta examples/fizzbuzz.kap
 or
 
 ```
-exe/kapusta --compile examples/fizzbuzz.kap > examples/fizzbuzz.rb
+kapusta --compile examples/fizzbuzz.kap > examples/fizzbuzz.rb
 ruby examples/fizzbuzz.rb
 ```
 
-For mruby-compatible output, such as DragonRuby, use:
+For mruby 3 compatible output, such as DragonRuby, use:
 
 ```
-exe/kapusta --compile --target=mruby examples/match.kap > examples/match-mruby.rb
+kapusta --compile --target=mruby3 examples/match.kap > examples/match-mruby3.rb
 ```
 
 ## Use from Ruby
@@ -105,6 +103,7 @@ Kapusta keeps most core Fennel forms. The main differences come from Ruby's runt
 | `string.format`, `table.insert`, etc. | use Ruby methods and stdlib instead                   |
 | `values` uses Lua multiple returns    | `values` lowers to a Ruby array, usually destructured |
 | `(print x)` is Lua's `print` (bare)   | `(print x)` is Ruby's `p` (inspect-style)             |
+| `(.. "x: " nil)` errors at runtime    | `(.. "x: " nil)` produces `"x: "` (Ruby `nil.to_s`)   |
 | `with-open`, `tail!`                  | not provided                                          |
 
 Kapusta-specific additions:
@@ -115,8 +114,8 @@ Kapusta-specific additions:
 - `ivar` or `@var` / `cvar` or `@@var` / `gvar` or `$var`
 - `try` / `catch` / `finally` plus `raise` for exceptions
 - `(ruby "...")` raw host escape hatch
-- a trailing symbol-keyed hash is emitted as Ruby keyword arguments
-- a final function literal argument is emitted as a Ruby block
+- pass Ruby keyword arguments by ending a call with a symbol-keyed hash: `(File.open path "r" {:encoding "UTF-8"})`
+- pass a Ruby block by ending a call with a `(fn ...)` or `#(...)` literal: `(File.open path "r" (fn [io] (: io :read)))`
 
 ## Format
 
@@ -130,7 +129,7 @@ Use `kapusta-ls` in the editor of your choice.
 
 ## Syntax highlight
 
-For Vim, you can use https://git.sr.ht/~m15a/vim-fennel-syntax
+For Vim, you can use [`vim-syntax/`](https://github.com/evmorov/kapusta/tree/main/vim-syntax/).
 
 ## License
 

data/examples/arrange-coins.kap

@@ -0,0 +1,32 @@
+(fn arrange-coins [n]
+  (let [rows (faccumulate [acc {:sum 0 :rows 0} i 1 n]
+               (let [new-sum (+ (. acc :sum) i)]
+                 (if (<= new-sum n)
+                     {:sum new-sum :rows i}
+                     acc)))
+        used (faccumulate [acc {:sum 0 :rows 0} i 1 n]
+               (let [new-sum (+ (. acc :sum) i)]
+                 (if (<= new-sum n)
+                     {:sum new-sum :rows i}
+                     acc)))]
+    [(. rows :rows) (. used :sum)]))
+
+(let [[r u] (arrange-coins 0)]
+  (print r)
+  (print u))
+
+(let [[r u] (arrange-coins 1)]
+  (print r)
+  (print u))
+
+(let [[r u] (arrange-coins 5)]
+  (print r)
+  (print u))
+
+(let [[r u] (arrange-coins 8)]
+  (print r)
+  (print u))
+
+(let [[r u] (arrange-coins 10)]
+  (print r)
+  (print u))

data/examples/array-sign.kap

@@ -0,0 +1,24 @@
+(fn sign [n]
+  (if (> n 0) 1
+      (< n 0) -1
+      0))
+
+(fn array-sign [nums]
+  (accumulate [acc 1 _ n (ipairs nums)]
+    (* acc (sign n))))
+
+(fn join [tbl sep]
+  (var s "")
+  (each [_ x (ipairs tbl)]
+    (if (= s "")
+        (set s (.. x))
+        (set s (.. s sep x))))
+  s)
+
+(fn debug-sign [label nums]
+  (local pretty #(.. "[" (join $ ", ") "]"))
+  (.. "case[" label "] in " (pretty nums) " out " (array-sign nums)))
+
+(print (debug-sign "mixed" [-1 -2 -3 -4 3 2 1]))
+(print (debug-sign "withzero" [1 5 0 2 -3]))
+(print (debug-sign "allneg" [-1 1 -1 1 -1]))

data/examples/case-vs-match.kap

@@ -0,0 +1,23 @@
+(fn debug-data [packet seq]
+  (local no-nil #(or $ "nil"))
+  (let [[_ packet-seq] packet]
+    (.. "packet[:ping, " (no-nil packet-seq) "] seq " (no-nil seq))))
+
+(fn show-case [packet seq]
+  (case packet
+    [:ping seq] (debug-data packet seq)
+    _ "other"))
+
+(fn show-match [packet seq]
+  (match packet
+    [:ping seq] (debug-data packet seq)
+    _ "other"))
+
+(print (.. "case: " (show-case [:ping 42] 7)))
+(print (.. "case: " (show-case [:ping 42] nil)))
+(print (.. "case: " (show-case [:ping nil] nil)))
+(print (.. "case: " (show-case [:ping 42] 42)))
+(print (.. "match: " (show-match [:ping 42] 7)))
+(print (.. "match: " (show-match [:ping 42] nil)))
+(print (.. "match: " (show-match [:ping nil] nil)))
+(print (.. "match: " (show-match [:ping 42] 42)))

data/examples/divisibility-stats.kap

@@ -0,0 +1,16 @@
+(fn divisibility-stats [n]
+  (let [threes (faccumulate [acc 0 i 1 n]
+                 (let [step (if (= 0 (% i 3)) 1 0)]
+                   (+ acc step)))
+        fives (faccumulate [acc 0 i 1 n]
+                (let [step (if (= 0 (% i 5)) 1 0)]
+                  (+ acc step)))]
+    [threes fives]))
+
+(let [[t f] (divisibility-stats 30)]
+  (print t)
+  (print f))
+
+(let [[t f] (divisibility-stats 100)]
+  (print t)
+  (print f))

data/examples/equal-sums.kap

@@ -0,0 +1,7 @@
+(fn equal-sums? [a b]
+  (= (accumulate [s 0 _ x (ipairs a)] (+ s x))
+     (accumulate [s 0 _ x (ipairs b)] (+ s x))))
+
+(print (equal-sums? [1 2 3] [3 2 1]))
+(print (equal-sums? [1 2 3] [4 5 6]))
+(print (equal-sums? [0] [0]))

data/examples/fennel-parity-examples.txt

@@ -1,11 +1,16 @@
 ackermann
 anonymous-greeter
+array-sign
+arrange-coins
+case-vs-match
 classify-wallet
 climbing-stairs
 convert-temperature
 count-effects
 describe
 destructure
+divisibility-stats
+equal-sums
 even-squares
 factorial
 falling-drops
@@ -15,9 +20,9 @@ gcd
 hashfn
 leap-year
 macros-dbg
+macros-import
 macros-import-helpers
 macros-import-whole
-macros-import
 macros-multi
 macros-swap
 macros-thrice-if
@@ -26,10 +31,12 @@ macros-when-let
 match
 max-achievable
 min-max
+nested-nil-pattern
+non-constant-local
 or-patterns
-power-of-three
 packet-router
 points
+power-of-three
 primes
 safe-lookup
 shapes

data/examples/mruby-runtime-examples.txt

@@ -3,6 +3,7 @@ accumulator
 ackermann
 anagram
 anonymous-greeter
+arrange-coins
 bank-account
 baseball-game
 best-time-to-buy-sell-stock
@@ -11,6 +12,7 @@ binary-to-decimal
 block-sort
 bst-iterator
 calc
+case-vs-match
 circle
 classify-wallet
 climbing-stairs
@@ -20,8 +22,9 @@ count-effects
 counter
 describe
 destructure
-doto-hygiene
+divisibility-stats
 doto
+doto-hygiene
 egg-count
 even-squares
 exceptions
@@ -38,9 +41,9 @@ kwargs
 leap-year
 length-of-last-word
 macros-dbg
+macros-import
 macros-import-helpers
 macros-import-whole
-macros-import
 macros-multi
 macros-swap
 macros-thrice-if
@@ -53,6 +56,7 @@ max-achievable
 maximum-subarray
 min-max
 module-header
+nested-nil-pattern
 move-zeroes
 number-of-1-bits
 number-of-steps
@@ -84,8 +88,8 @@ thread-styles
 threading
 tic-tac-toe
 tset
-two-sum-hash
 two-sum
+two-sum-hash
 ugly-number
 underscore-patterns
 valid-parentheses-1

data/examples/nested-nil-pattern.kap

@@ -0,0 +1,7 @@
+(fn check [packet]
+  (case packet
+    [:ping seq] (.. "got " seq)
+    _ "other"))
+
+(print (check [:ping 42]))
+(print (check [:ping nil]))

data/examples/non-constant-local.kap

@@ -0,0 +1,11 @@
+(local hash-fn #(or $ "nil"))
+(local regular-fn (fn [x] (+ x 1)))
+(local lambda-fn (λ [x] (* x 2)))
+(local vec-binding [10 20 30])
+(local hash-binding {:a 1})
+
+(print (hash-fn nil))
+(print (regular-fn 5))
+(print (lambda-fn 5))
+(print (length vec-binding))
+(print (. hash-binding :a))

data/lib/kapusta/cli.rb

@@ -39,7 +39,7 @@ module Kapusta
       OptionParser.new do |parser|
         parser.banner = usage
         parser.on('-c', '--compile', 'Compile .kap to Ruby') { options.compile = true }
-        parser.on('--target=TARGET', 'Compile for mruby') do |target|
+        parser.on('--target=TARGET', 'Compile for mruby3') do |target|
           options.target = Kapusta::Compiler.normalize_target(target)
         end
         parser.on('-h', '--help', 'Show this help') { options.help = true }
@@ -69,7 +69,7 @@ module Kapusta
     end
 
     def self.usage
-      'usage: kapusta [--compile|-c] [--target=mruby] <file.kap> | kapusta <file.kap> [args...]'
+      'usage: kapusta [--compile|-c] [--target=mruby3] <file.kap> | kapusta <file.kap> [args...]'
     end
   end
 end

data/lib/kapusta/compiler/emitter/bindings.rb

@@ -57,7 +57,7 @@ module Kapusta
 
         def build_simple_block_parts(pattern, body, env, current_scope)
           body_env = env.child
-          params = pattern.items.map { |sym| define_local(body_env, sym.name, shadow: true) }
+          params = pattern.items.map { |sym| define_local(body_env, sym, shadow: true) }
           body_code, = emit_sequence(body, body_env, current_scope,
                                      allow_method_definitions: false, result: false)
           [params, body_code]
@@ -178,7 +178,7 @@ module Kapusta
 
         def emit_toplevel_method_bridge(ruby_name)
           method_name = ruby_name.to_sym.inspect
-          if mruby_target?
+          if mruby3_target?
             return [
               "define_singleton_method(#{method_name}) do |*args|",
               indent("Object.instance_method(#{method_name}).bind(self).call(*args)"),
@@ -296,7 +296,9 @@ module Kapusta
 
           if target.is_a?(Sym)
             validate_binding_symbol!(target)
-            if allow_constant && form.head.name == 'local' && (constant_name = constant_name_for(target.name))
+            if allow_constant && form.head.name == 'local' &&
+               constant_value?(form.items[2]) &&
+               (constant_name = constant_name_for(target.name))
               env.define(target.name, constant_name)
               mark_mutability(env, target.name, mutable: false)
               return ["#{constant_name} = #{value_code}\nnil", env]
@@ -316,6 +318,13 @@ module Kapusta
           candidate if candidate.match?(/\A[A-Z][A-Z0-9_]*\z/)
         end
 
+        def constant_value?(value_form)
+          case value_form
+          when Numeric, String, ::Symbol, true, false, nil then true
+          else false
+          end
+        end
+
         def check_destructure_value!(pattern, value_form)
           return unless pattern.is_a?(Vec) || pattern.is_a?(HashLit)
 

data/lib/kapusta/compiler/emitter/collections.rb

@@ -111,30 +111,23 @@ module Kapusta
           bindings = args[0].items
           emit_error!(:accumulate_no_iterator) if bindings.length < 5
 
-          acc_name = bindings[0]
-          loop_name = bindings[2]
-          loop_env = env.child
-          acc_var = define_local(loop_env, acc_name.name)
-          loop_var = define_local(loop_env, loop_name.name)
-          body_code, = emit_sequence(args[1..], loop_env, current_scope, allow_method_definitions: false)
-          accumulating_body = emit_sequence_value_assignment(acc_var, body_code)
-          loop_code = emit_counted_loop(
-            ruby_name: loop_var,
-            start_code: emit_expr(bindings[3], env, current_scope),
-            finish_code: emit_expr(bindings[4], env, current_scope),
-            step_code: bindings[5] ? emit_expr(bindings[5], env, current_scope) : '1',
-            until_form: nil,
-            loop_env:,
-            current_scope:,
-            body_code: accumulating_body
-          )
-          [
-            '(-> do',
-            indent("#{acc_var} = #{emit_expr(bindings[1], env, current_scope)}"),
-            indent(loop_code),
-            indent(acc_var),
-            'end).call'
-          ].join("\n")
+          body_env = env.child
+          acc_var = define_local(body_env, bindings[0].name)
+          loop_var = define_local(body_env, bindings[2].name)
+
+          init_code = emit_expr(bindings[1], env, current_scope)
+          start_code = emit_expr(bindings[3], env, current_scope)
+          finish_code = emit_expr(bindings[4], env, current_scope)
+          step_code = bindings[5] ? emit_expr(bindings[5], env, current_scope) : nil
+          body_code, = emit_sequence(args[1..], body_env, current_scope, allow_method_definitions: false)
+
+          receiver =
+            if step_code
+              "#{parenthesize(start_code)}.step(#{finish_code}, #{step_code})"
+            else
+              "(#{start_code}..#{finish_code})"
+            end
+          inject_block(receiver, "#{acc_var}, #{loop_var}", init_code, '', body_code)
         end
 
         def emit_hashfn(args, env, current_scope)

data/lib/kapusta/compiler/emitter/control_flow.rb

@@ -96,7 +96,7 @@ module Kapusta
         end
 
         def emit_case_body(value_var, clauses, env, current_scope, mode)
-          return try_emit_compat_case(value_var, clauses, env, current_scope, mode) if mruby_target?
+          return try_emit_compat_case(value_var, clauses, env, current_scope, mode) if mruby3_target?
 
           try_emit_native_case(value_var, clauses, env, current_scope, mode) ||
             try_emit_compat_case(value_var, clauses, env, current_scope, mode)

data/lib/kapusta/compiler/emitter/support.rb

@@ -25,8 +25,8 @@ module Kapusta
           (@form_stack ||= []).last
         end
 
-        def mruby_target?
-          @target == :mruby
+        def mruby3_target?
+          @target == :mruby3
         end
 
         def positionable?(form)

data/lib/kapusta/compiler/normalizer.rb

@@ -139,6 +139,8 @@ module Kapusta
 
       def doto(forms)
         value = forms.first
+        return value if forms[1..].empty?
+
         temp = gensym('doto')
         body = forms[1..].map do |form|
           if form.is_a?(List)
@@ -147,7 +149,8 @@ module Kapusta
             List.new([form, temp])
           end
         end
-        List.new([Sym.new('let'), Vec.new([temp, value]), *body, temp])
+        fn = List.new([Sym.new('fn'), Vec.new([temp]), *body])
+        List.new([Sym.new(':'), value, :tap, fn])
       end
 
       def gensym(prefix)

data/lib/kapusta/compiler.rb

@@ -61,7 +61,7 @@ module Kapusta
     def self.normalize_target(target)
       case target
       when nil then nil
-      when :mruby, 'mruby' then :mruby
+      when :mruby3, 'mruby3', :mruby, 'mruby' then :mruby3
       else
         raise Error, Kapusta::Errors.format(:unknown_target, target: target.inspect)
       end

data/lib/kapusta/errors.rb

@@ -64,7 +64,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',
+      unknown_target: 'unknown target %{target}; only mruby3 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

@@ -555,30 +555,18 @@ module Kapusta
       lines = [base]
       args = list_raw_rest(list)
       semantic_length = semantic_items(args).length
+      hang_subsequent_args = hang_call_args?(list, indent)
 
       semantic_index = 0
+      hanging = nil
       args.each do |arg|
         if comment?(arg)
           lines << indent_block(render(arg, indent + INDENT), INDENT)
           next
-        end
-
-        if semantic_index.zero?
-          first = render(
-            arg,
-            indent + base.length + 1,
-            force_expand: semantic_length == 1 && fn_form?(arg)
-          )
-          first_line, *rest = first.lines(chomp: true)
-          candidate = "#{base} #{first_line}"
-
-          if lines.length == 1 && fits?(candidate, indent)
-            lines[0] = candidate
-            hanging = ' ' * (base.length + 1)
-            rest.each { |line| lines << "#{hanging}#{line}" }
-          else
-            lines << indent_block(first, INDENT)
-          end
+        elsif semantic_index.zero?
+          hanging = append_first_call_arg(lines, arg, base, indent, semantic_length)
+        elsif hanging && hang_subsequent_args
+          lines << prefix_continuation(hanging, render(arg, indent + hanging.length))
         else
           lines << indent_block(render(arg, indent + INDENT), INDENT)
         end
@@ -589,6 +577,48 @@ module Kapusta
       append_suffix(lines, ')')
     end
 
+    def append_first_call_arg(lines, arg, base, indent, semantic_length)
+      first = render(
+        arg,
+        indent + base.length + 1,
+        force_expand: semantic_length == 1 && fn_form?(arg)
+      )
+      first_line, *rest = first.lines(chomp: true)
+      candidate = "#{base} #{first_line}"
+
+      unless lines.length == 1 && fits?(candidate, indent)
+        lines << indent_block(first, INDENT)
+        return
+      end
+
+      hanging = ' ' * (base.length + 1)
+      lines[0] = candidate
+      rest.each { |line| lines << "#{hanging}#{line}" }
+      hanging
+    end
+
+    def hang_call_args?(list, indent)
+      return false unless operator_call?(list)
+
+      flat = flat_call_render(list)
+      flat && !fits?(flat, indent)
+    end
+
+    def operator_call?(list)
+      head = list_head(list)
+      head.is_a?(Sym) && head.name.match?(/\A[^\w.]+\z/)
+    end
+
+    def flat_call_render(list)
+      head = flat_render(list_head(list))
+      return unless head
+
+      rendered_args = semantic_items(list_raw_rest(list)).map { |arg| flat_render(arg) }
+      return if rendered_args.any?(&:nil?)
+
+      "(#{[head, *rendered_args].join(' ')})"
+    end
+
     def render_vec(vec, indent, layout: nil, top_level: false, force_expand: false)
       flat = flat_render(vec)
       return flat if !force_expand && flat && fits?(flat, indent) && allow_flat?(vec, top_level:, layout:)
@@ -800,8 +830,7 @@ module Kapusta
            'fn', 'lambda', 'λ', 'macro'
         true
       else
-        flat = flat_render(form)
-        flat && flat.length > 40
+        false
       end
     end
 

data/lib/kapusta/lsp.rb

@@ -15,8 +15,38 @@ module Kapusta
     METHOD_NOT_FOUND = -32_601
     FULL_SYNC = 1
 
+    def self.debug?
+      %w[1 true yes on].include?(ENV['KAPUSTA_LS_DEBUG'].to_s.downcase)
+    end
+
     def self.start(input: $stdin, output: $stdout, log: $stderr)
-      new(input:, output:, log:).run
+      server = new(input:, output:, log:)
+      install_signal_handlers(log)
+      server.run
+      debug_log(log, 'run returned, calling exit!(0)')
+      exit!(0)
+    end
+
+    def self.install_signal_handlers(log)
+      %w[TERM INT HUP].each do |sig|
+        Signal.trap(sig) do
+          debug_log(log, "signal #{sig} received, exiting")
+          exit!(0)
+        rescue StandardError
+          exit!(0)
+        end
+      rescue ArgumentError
+        nil
+      end
+    end
+
+    def self.debug_log(log, message)
+      return unless debug?
+
+      log.write("kapusta-ls[debug pid=#{Process.pid}]: #{message}\n")
+      log.flush
+    rescue StandardError
+      nil
     end
 
     def self.uri_to_path(uri)
@@ -34,7 +64,7 @@ module Kapusta
       @input = input.binmode
       @output = output.binmode
       @log = log
-      @debug = %w[1 true yes on].include?(ENV['KAPUSTA_LS_DEBUG'].to_s.downcase)
+      @debug = LSP.debug?
       @sources = {}
       @workspace_index = WorkspaceIndex.new
       @initialized = false
@@ -42,9 +72,11 @@ module Kapusta
     end
 
     def run
+      debug('run loop start')
       until (message = read_message).nil?
         handle(message)
       end
+      debug('stdin EOF, run loop exiting')
     end
 
     private
@@ -83,8 +115,14 @@ module Kapusta
 
     def write_message(payload)
       body = JSON.generate(payload)
+      tag = payload[:id] ? "response id=#{payload[:id]}" : "notify #{payload[:method]}"
+      debug("write begin (#{tag}, #{body.bytesize} bytes)")
       @output.write("Content-Length: #{body.bytesize}\r\n\r\n#{body}")
       @output.flush
+      debug("write done (#{tag})")
+    rescue Errno::EPIPE, IOError => e
+      debug("write failed (#{e.class}: #{e.message}), exiting")
+      exit!(0)
     end
 
     def handle(message)
@@ -92,9 +130,11 @@ module Kapusta
       id = message['id']
       params = message['params'] || {}
 
+      debug("dispatch begin method=#{method.inspect} id=#{id.inspect}")
       return handle_pre_init(method, id, params) unless @initialized || method == 'initialize' || method == 'exit'
 
       dispatch(method, id, params)
+      debug("dispatch end method=#{method.inspect} id=#{id.inspect}")
     rescue StandardError => e
       log("#{e.class}: #{e.message}")
       log(e.backtrace.first(5).join("\n"))
@@ -116,8 +156,12 @@ module Kapusta
       when 'initialized' then nil
       when 'shutdown'
         @shutdown = true
+        debug('shutdown received, replying and arming watchdog')
         reply(id, nil)
-      when 'exit' then exit(@shutdown ? 0 : 1)
+        arm_shutdown_watchdog
+      when 'exit'
+        debug("exit notification received (shutdown=#{@shutdown}), calling exit!")
+        exit!(@shutdown ? 0 : 1)
       when 'textDocument/didOpen' then on_did_open(params)
       when 'textDocument/didChange' then on_did_change(params)
       when 'textDocument/didSave' then on_did_save(params)
@@ -300,14 +344,28 @@ module Kapusta
       notify('textDocument/publishDiagnostics', params)
     end
 
+    def arm_shutdown_watchdog(seconds: 2)
+      Thread.new do
+        sleep seconds
+        debug("shutdown watchdog firing after #{seconds}s, forcing exit")
+        exit!(0)
+      end
+    end
+
     def log(message)
       @log.puts "kapusta-ls: #{message}"
+      @log.flush
+    rescue StandardError
+      nil
     end
 
     def debug(message)
       return unless @debug
 
-      @log.puts "kapusta-ls[debug]: #{message}"
+      @log.write("kapusta-ls[debug pid=#{Process.pid}]: #{message}\n")
+      @log.flush
+    rescue StandardError
+      nil
     end
   end
 end

data/lib/kapusta/version.rb

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

data/spec/cli_spec.rb

@@ -66,11 +66,11 @@ RSpec.describe Kapusta::CLI do
     end
   end
 
-  it 'compiles case and match forms for mruby with --target=mruby' do
+  it 'compiles case and match forms for mruby3 with --target=mruby3' do
     path = File.expand_path('../examples/match.kap', __dir__)
 
     ruby = capture_stdout do
-      described_class.start(['--compile', '--target=mruby', path])
+      described_class.start(['--compile', '--target=mruby3', path])
     end
 
     expect(ruby).not_to match(/^\s*in\b/)
@@ -98,14 +98,14 @@ RSpec.describe Kapusta::CLI do
         .to raise_error(SystemExit)
     end
 
-    expect(error_output).to include('unknown target "mri"; only mruby is supported')
+    expect(error_output).to include('unknown target "mri"; only mruby3 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]) }
+      expect { described_class.start(['--target=mruby3', path]) }
         .to raise_error(SystemExit)
     end
 

data/spec/examples_spec.rb

@@ -76,6 +76,29 @@ RSpec.describe 'examples' do
     expect(run_example('ackermann.kap')).to eq("9\n61\n")
   end
 
+  it 'non-constant-local.kap' do
+    expect(run_example('non-constant-local.kap')).to eq(<<~OUT)
+      "nil"
+      6
+      10
+      3
+      1
+    OUT
+  end
+
+  it 'case-vs-match.kap' do
+    expect(run_example('case-vs-match.kap')).to eq(<<~OUT)
+      "case: packet[:ping, 42] seq 42"
+      "case: packet[:ping, 42] seq 42"
+      "case: other"
+      "case: packet[:ping, 42] seq 42"
+      "match: other"
+      "match: other"
+      "match: packet[:ping, nil] seq nil"
+      "match: packet[:ping, 42] seq 42"
+    OUT
+  end
+
   it 'accumulator.kap' do
     expect(run_example('accumulator.kap')).to eq("22\n")
   end
@@ -92,6 +115,30 @@ RSpec.describe 'examples' do
     expect(run_example('circle.kap')).to eq("78.53975\n31.4159\n")
   end
 
+  it 'arrange-coins.kap' do
+    expect(run_example('arrange-coins.kap')).to eq(<<~OUT)
+      0
+      0
+      1
+      1
+      2
+      3
+      3
+      6
+      4
+      10
+    OUT
+  end
+
+  it 'divisibility-stats.kap' do
+    expect(run_example('divisibility-stats.kap')).to eq(<<~OUT)
+      10
+      6
+      33
+      20
+    OUT
+  end
+
   it 'anagram.kap' do
     expect(run_example('anagram.kap')).to eq("true\ntrue\nfalse\n")
   end
@@ -444,15 +491,10 @@ 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"
+  it 'nested-nil-pattern.kap' do
+    expect(run_example('nested-nil-pattern.kap')).to eq(<<~OUT)
+      "got 42"
+      "other"
     OUT
   end
 
@@ -699,7 +741,7 @@ RSpec.describe 'mruby runtime examples' do
       if mruby_status.success? && mruby_stdout == expected
         expect(run_mruby_source(ruby, path:)).to eq(expected)
       else
-        mruby_ruby = compile_example(name, target: :mruby)
+        mruby_ruby = compile_example(name, target: :mruby3)
 
         if mruby_ruby == ruby
           expect(mruby_status).to be_success

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: kapusta
 version: !ruby/object:Gem::Version
-  version: 0.11.1
+  version: 0.12.0
 platform: ruby
 authors:
 - Evgenii Morozov
@@ -31,6 +31,8 @@ files:
 - examples/ackermann.kap
 - examples/anagram.kap
 - examples/anonymous-greeter.kap
+- examples/arrange-coins.kap
+- examples/array-sign.kap
 - examples/bank-account.kap
 - examples/baseball-game.kap
 - examples/best-time-to-buy-sell-stock.kap
@@ -40,6 +42,7 @@ files:
 - examples/blocks-and-kwargs.kap
 - examples/bst-iterator.kap
 - examples/calc.kap
+- examples/case-vs-match.kap
 - examples/circle.kap
 - examples/classify-wallet.kap
 - examples/climbing-stairs.kap
@@ -49,9 +52,11 @@ files:
 - examples/counter.kap
 - examples/describe.kap
 - examples/destructure.kap
+- examples/divisibility-stats.kap
 - examples/doto-hygiene.kap
 - examples/doto.kap
 - examples/egg-count.kap
+- examples/equal-sums.kap
 - examples/even-squares.kap
 - examples/exceptions.kap
 - examples/factorial.kap
@@ -87,6 +92,8 @@ files:
 - examples/module-header.kap
 - examples/move-zeroes.kap
 - examples/mruby-runtime-examples.txt
+- examples/nested-nil-pattern.kap
+- examples/non-constant-local.kap
 - examples/number-of-1-bits.kap
 - examples/number-of-steps.kap
 - examples/or-patterns.kap