kapusta 0.13.2 → 0.15.0

data/spec/lsp_spec.rb

@@ -111,6 +111,16 @@ RSpec.describe Kapusta::LSP do
     expect(responses.last.dig('params', 'diagnostics')).to be_empty
   end
 
+  it 'publishes diagnostics for an unknown class body form' do
+    responses = run(
+      frame_initialize,
+      frame_did_open('file:///x.kap', "(class BankAccount)\n\n(n initialize [owner balance]\n  owner)\n\n(end)\n")
+    )
+
+    expect(responses.last.dig('params', 'diagnostics', 0, 'message'))
+      .to eq('class body form must be a declaration or known special form: n')
+  end
+
   it 'returns a TextEdit for formatting' do
     responses = run(
       frame_initialize,
@@ -123,6 +133,18 @@ RSpec.describe Kapusta::LSP do
     expect(edits.first).to include('range', 'newText')
   end
 
+  it 'formats through the LSP without collapsing full hash pairs into shorthand' do
+    text = "(let [active [] id 7]\n{:active active : id})\n"
+    responses = run(
+      frame_initialize,
+      frame_did_open('file:///x.kap', text),
+      frame_formatting(uri: 'file:///x.kap')
+    )
+    edits = result_for(responses)['result']
+
+    expect(edits.first['newText']).to include('{:active active : id}')
+  end
+
   it 'rejects requests sent before initialize' do
     responses = run(
       frame(jsonrpc: '2.0', id: 1, method: 'textDocument/formatting',
@@ -145,6 +167,35 @@ RSpec.describe Kapusta::LSP do
     expect(changes.first['edits'].map { |e| e['newText'] }).to eq(%w[y y y])
   end
 
+  it 'renames only the base binding in a colon hash lookup shorthand' do
+    text = "(let [user {:name \"Ada\"}]\n  (print user:name))\n"
+    responses = run(
+      frame_initialize,
+      frame_did_open('file:///x.kap', text),
+      frame_rename(uri: 'file:///x.kap', **cursor_at(text, 'user:name'), new_name: 'person')
+    )
+    edits = result_for(responses)['result']['documentChanges'].first['edits']
+
+    expect(edits.map { |e| e['newText'] }).to eq(%w[person person])
+    expect(edits.map { |e| [e['range']['start']['line'], e['range']['start']['character']] })
+      .to contain_exactly([0, 6], [1, 9])
+  end
+
+  it 'does not offer rename on a colon hash key segment' do
+    text = "(let [user {:name \"Ada\"}]\n  (print user:name))\n"
+    key_index = text.index('user:name') + 'user:'.length
+    prefix = text[0...key_index]
+    last_nl = prefix.rindex("\n")
+    position = { line: prefix.count("\n"), character: last_nl ? key_index - last_nl - 1 : key_index }
+    responses = run(
+      frame_initialize,
+      frame_did_open('file:///x.kap', text),
+      frame_prepare_rename(uri: 'file:///x.kap', **position)
+    )
+
+    expect(result_for(responses)['result']).to be_nil
+  end
+
   it 'renames a let binding referenced inside an accumulate iterator with multiple binders' do
     text = "(let [xs [1 2 3]\n      total (accumulate [s 0 _ x (ipairs xs)] (+ s x))]\n  (print total))\n"
     idx = text.index('(ipairs xs)') + 'ipairs '.length + 1
@@ -359,6 +410,24 @@ RSpec.describe Kapusta::LSP do
     )
   end
 
+  it 'jumps from a colon hash lookup base to its local binding' do
+    text = "(let [user {:name \"Ada\"}]\n  user:name)\n"
+    responses = run(
+      frame_initialize,
+      frame_did_open('file:///x.kap', text),
+      frame_definition(uri: 'file:///x.kap', **cursor_at(text, 'user:name'))
+    )
+    result = result_for(responses)['result']
+
+    expect(result).to eq(
+      'uri' => 'file:///x.kap',
+      'range' => {
+        'start' => { 'line' => 0, 'character' => 6 },
+        'end' => { 'line' => 0, 'character' => 10 }
+      }
+    )
+  end
+
   it 'rejects renaming a class to a lowercase name with a clear message' do
     text = "(class Accumulator)\n\n(end)\n"
     responses = run(

data/spec/require_spec.rb

@@ -0,0 +1,294 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'fileutils'
+require 'tmpdir'
+
+RSpec.describe 'Kapusta require' do
+  it 'returns cached final values from .kap relative requires resolved from the current .kap file' do
+    Dir.mktmpdir('kapusta-require-local') do |dir|
+      app_dir = File.join(dir, 'app')
+      other_dir = File.join(dir, 'other')
+      FileUtils.mkdir_p([app_dir, other_dir])
+      counter_path = File.join(dir, 'loads.txt')
+
+      File.write(File.join(app_dir, 'args.kap'), <<~KAP)
+        (ruby #{"File.write(#{counter_path.inspect}, 'x', mode: 'a')".inspect})
+
+        (fn parse [argv]
+          (argv.join ","))
+
+        {: parse}
+      KAP
+
+      File.write(File.join(app_dir, 'main.kap'), <<~KAP)
+        (local args (require "./args"))
+        (local again (require "./args"))
+
+        [((: args :parse) ["alpha" "beta"])
+         ((: again :parse) ["gamma"])]
+      KAP
+
+      result = Dir.chdir(other_dir) do
+        Kapusta.dofile(File.join(app_dir, 'main.kap'))
+      end
+
+      expect(result).to eq(['alpha,beta', 'gamma'])
+      expect(File.read(counter_path)).to eq('x')
+    end
+  end
+
+  it 'calls functions on required .kap module maps with colon syntax' do
+    Dir.mktmpdir('kapusta-require-local-map-call') do |dir|
+      File.write(File.join(dir, 'probe.kap'), <<~KAP)
+        (fn parse-size [output]
+          (.. "size:" output))
+
+        {: parse-size}
+      KAP
+
+      File.write(File.join(dir, 'main.kap'), <<~KAP)
+        (local probe (require "./probe"))
+
+        (probe:parse-size "42 120")
+      KAP
+
+      expect(Kapusta.dofile(File.join(dir, 'main.kap'))).to eq('size:42 120')
+    end
+  end
+
+  it 'keeps dotted calls on required .kap module maps as method calls' do
+    Dir.mktmpdir('kapusta-require-local-map-dotted-call') do |dir|
+      File.write(File.join(dir, 'probe.kap'), <<~KAP)
+        (fn parse-size [output]
+          (.. "size:" output))
+
+        {: parse-size}
+      KAP
+
+      main_path = File.join(dir, 'main.kap')
+      File.write(main_path, <<~KAP)
+        (local probe (require "./probe"))
+
+        (probe.parse-size "42 120")
+      KAP
+
+      expect(Kapusta.compile(File.read(main_path), path: main_path)).to eq(<<~RUBY)
+        probe = require_relative "probe"
+        probe.parse_size("42 120")
+      RUBY
+    end
+  end
+
+  it 'compiles local aliases for .kap module requires to plain Ruby require and constant assignment' do
+    Dir.mktmpdir('kapusta-require-module-local-alias') do |dir|
+      app_dir = File.join(dir, 'app')
+      FileUtils.mkdir_p(app_dir)
+      File.write(File.join(app_dir, 'search.kap'), <<~KAP)
+        (module App.Search)
+
+        (defn active? [state]
+          true)
+
+        (end)
+      KAP
+      main_path = File.join(dir, 'main.kap')
+      File.write(main_path, <<~KAP)
+        (local search (require :app.search))
+        (search.active? {})
+      KAP
+
+      expect(Kapusta.compile(File.read(main_path), path: main_path)).to eq(<<~RUBY)
+        require_relative "app/search"
+        search = App::Search
+        search.active?({})
+      RUBY
+    end
+  end
+
+  it 'keeps nested module require aliases isolated when names repeat' do
+    Dir.mktmpdir('kapusta-require-module-nested-alias') do |dir|
+      app_dir = File.join(dir, 'app')
+      FileUtils.mkdir_p(app_dir)
+
+      File.write(File.join(app_dir, 'base.kap'), <<~KAP)
+        (module App.Base)
+
+        (defn value []
+          "base")
+
+        (end)
+      KAP
+
+      File.write(File.join(app_dir, 'inner.kap'), <<~KAP)
+        (module App.Inner)
+
+        (local mod (require "./base"))
+
+        (defn value []
+          (.. "inner:" (mod.value)))
+
+        (end)
+      KAP
+
+      File.write(File.join(app_dir, 'outer.kap'), <<~KAP)
+        (module App.Outer)
+
+        (local mod (require "./inner"))
+
+        (defn value []
+          (.. "outer:" (mod.value)))
+
+        (end)
+      KAP
+
+      main_path = File.join(dir, 'main.kap')
+      File.write(main_path, <<~KAP)
+        (local mod (require :app.outer))
+        (mod.value)
+      KAP
+
+      expect(Kapusta.dofile(main_path)).to eq('outer:inner:base')
+    end
+  end
+
+  it 'compiles class instances created after relative requires' do
+    Dir.mktmpdir('kapusta-require-class-instance') do |dir|
+      app_dir = File.join(dir, 'app')
+      platform_dir = File.join(dir, 'platform')
+      FileUtils.mkdir_p([app_dir, platform_dir])
+
+      File.write(File.join(platform_dir, 'browser.kap'), <<~KAP)
+        (class RequireClassInstance.Browser)
+
+        (fn open [url]
+          url)
+
+        (end)
+      KAP
+
+      commands_path = File.join(app_dir, 'commands.kap')
+      File.write(commands_path, <<~KAP)
+        (class App.Commands)
+
+        (fn open [url]
+          (let [browser (do (require "../platform/browser") (RequireClassInstance.Browser.new))]
+            (browser.open url)))
+
+        (end)
+      KAP
+
+      expect(Kapusta.compile(File.read(commands_path), path: commands_path)).to eq(<<~RUBY)
+        module App
+          class Commands
+            def open(url)
+              browser = begin
+                require_relative "../platform/browser"
+                RequireClassInstance::Browser.new
+              end
+              browser.open(url)
+            end
+          end
+        end
+      RUBY
+    end
+  end
+
+  it 'keeps class instances isolated when required modules repeat local names' do
+    Dir.mktmpdir('kapusta-require-class-instance-isolation') do |dir|
+      app_dir = File.join(dir, 'app')
+      platform_dir = File.join(dir, 'platform')
+      FileUtils.mkdir_p([app_dir, platform_dir])
+
+      File.write(File.join(platform_dir, 'browser.kap'), <<~KAP)
+        (class RequireClassInstance.Browser)
+
+        (fn initialize [name]
+          (set @name name))
+
+        (fn open [url]
+          (.. @name ":" url))
+
+        (end)
+      KAP
+
+      File.write(File.join(app_dir, 'inner.kap'), <<~KAP)
+        (module App.Inner)
+
+        (defn open [url]
+          (let [browser (do (require "../platform/browser")
+                          (RequireClassInstance.Browser.new "inner-browser"))]
+            (browser.open (.. "inner:" url))))
+
+        (end)
+      KAP
+
+      File.write(File.join(app_dir, 'outer.kap'), <<~KAP)
+        (module App.Outer)
+
+        (require "./inner")
+
+        (defn open [url]
+          (let [browser (do (require "../platform/browser")
+                          (RequireClassInstance.Browser.new "outer-browser"))]
+            (.. (browser.open (.. "outer:" url)) "|" (App.Inner.open url))))
+
+        (end)
+      KAP
+
+      main_path = File.join(dir, 'main.kap')
+      File.write(main_path, <<~KAP)
+        (require :app.outer)
+        (App.Outer.open "x")
+      KAP
+
+      expect(Kapusta.dofile(main_path)).to eq('outer-browser:outer:x|inner-browser:inner:x')
+    end
+  end
+
+  it 'delegates relative requires to Ruby for .rb files' do
+    Dir.mktmpdir('kapusta-require-local-ruby') do |dir|
+      mod_name = "KapustaRequireRelativeRubyFeature#{rand(1_000_000)}"
+      File.write(File.join(dir, 'feature.rb'), <<~RUBY)
+        module #{mod_name}
+          VALUE = 7
+        end
+      RUBY
+      File.write(File.join(dir, 'main.kap'), <<~KAP)
+        (require "./feature")
+        (ruby "#{mod_name}::VALUE")
+      KAP
+
+      expect(Kapusta.dofile(File.join(dir, 'main.kap'))).to eq(7)
+    end
+  end
+
+  it 'returns cached final values from .kap module-path requires' do
+    Dir.mktmpdir('kapusta-require-module') do |dir|
+      app_dir = File.join(dir, 'app')
+      FileUtils.mkdir_p(app_dir)
+      counter_path = File.join(dir, 'loads.txt')
+
+      File.write(File.join(app_dir, 'args.kap'), <<~KAP)
+        (ruby #{"File.write(#{counter_path.inspect}, 'x', mode: 'a')".inspect})
+
+        (fn parse [argv]
+          (argv.join ":"))
+
+        {: parse}
+      KAP
+
+      begin
+        $LOAD_PATH.unshift(dir)
+        first = Kapusta.require(:'app.args')
+        second = Kapusta.require(:'app.args')
+
+        expect(first[:parse].call(%w[left right])).to eq('left:right')
+        expect(second).to equal(first)
+        expect(File.read(counter_path)).to eq('x')
+      ensure
+        $LOAD_PATH.delete(dir)
+      end
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: kapusta
 version: !ruby/object:Gem::Version
-  version: 0.13.2
+  version: 0.15.0
 platform: ruby
 authors:
 - Evgenii Morozov
@@ -31,6 +31,7 @@ files:
 - examples/ackermann.kap
 - examples/anagram.kap
 - examples/anonymous-greeter.kap
+- examples/app/args.kap
 - examples/arrange-coins.kap
 - examples/array-sign.kap
 - examples/bank-account.kap
@@ -49,15 +50,17 @@ files:
 - examples/contains-duplicate.kap
 - examples/convert-temperature.kap
 - examples/count-effects.kap
+- examples/count-items-matching-rule.kap
 - examples/counter.kap
-- examples/describe.kap
 - examples/destructure.kap
+- examples/digit-tools.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/excel-column.kap
 - examples/exceptions.kap
 - examples/factorial.kap
 - examples/falling-drops.kap
@@ -66,6 +69,7 @@ files:
 - examples/files.kap
 - examples/fizzbuzz.kap
 - examples/gcd.kap
+- examples/good-pairs.kap
 - examples/greet.kap
 - examples/happy-number.kap
 - examples/hashfn.kap
@@ -73,7 +77,9 @@ files:
 - examples/import-helpers.kapm
 - examples/kwargs.kap
 - examples/leap-year.kap
+- examples/left-right-difference.kap
 - examples/length-of-last-word.kap
+- examples/logger-rate-limiter.kap
 - examples/macros-dbg.kap
 - examples/macros-import-helpers.kap
 - examples/macros-import-whole.kap
@@ -89,6 +95,7 @@ files:
 - examples/max-achievable.kap
 - examples/maximum-subarray.kap
 - examples/min-max.kap
+- examples/minimum-start-value.kap
 - examples/module-header.kap
 - examples/move-zeroes.kap
 - examples/mruby-runtime-examples.txt
@@ -109,12 +116,18 @@ files:
 - examples/power-of-three.kap
 - examples/primes.kap
 - examples/raindrops.kap
+- examples/range-width.kap
 - examples/recent-counter.kap
 - examples/record.kap
 - examples/regex.kap
+- examples/require-local-args.kap
+- examples/require-local.kap
+- examples/require-module-local.kap
+- examples/require-module.kap
 - examples/reverse-integer.kap
 - examples/roman-to-integer.kap
 - examples/ruby-eval.kap
+- examples/running-sum.kap
 - examples/safe-lookup.kap
 - examples/scopes.kap
 - examples/shapes.kap
@@ -125,6 +138,7 @@ files:
 - examples/stack.kap
 - examples/subtract-product-sum.kap
 - examples/sum.kap
+- examples/summary-ranges.kap
 - examples/thread-styles.kap
 - examples/threading.kap
 - examples/tic-tac-toe.kap
@@ -132,6 +146,7 @@ files:
 - examples/two-sum-hash.kap
 - examples/two-sum.kap
 - examples/ugly-number.kap
+- examples/underground-system.kap
 - examples/underscore-patterns.kap
 - examples/use_bank_account.rb
 - examples/valid-parentheses-1.kap
@@ -155,6 +170,7 @@ files:
 - lib/kapusta/compiler/emitter/patterns.rb
 - lib/kapusta/compiler/emitter/simple_expression.rb
 - lib/kapusta/compiler/emitter/support.rb
+- lib/kapusta/compiler/language.rb
 - lib/kapusta/compiler/lua_compat.rb
 - lib/kapusta/compiler/macro_expander.rb
 - lib/kapusta/compiler/macro_gensym.rb
@@ -165,6 +181,10 @@ files:
 - lib/kapusta/error.rb
 - lib/kapusta/errors.rb
 - lib/kapusta/formatter.rb
+- lib/kapusta/formatter/ast_helpers.rb
+- lib/kapusta/formatter/cli.rb
+- lib/kapusta/formatter/line_helpers.rb
+- lib/kapusta/formatter/validator.rb
 - lib/kapusta/lsp.rb
 - lib/kapusta/lsp/definition.rb
 - lib/kapusta/lsp/diagnostics.rb
@@ -181,6 +201,7 @@ files:
 - spec/examples_spec.rb
 - spec/formatter_spec.rb
 - spec/lsp_spec.rb
+- spec/require_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/evmorov/kapusta
 licenses:

data/examples/describe.kap

@@ -1,9 +0,0 @@
-(fn describe [x]
-  (case x
-    0 "zero"
-    1 "one"
-    (where n (< n 0)) "negative"
-    _ "many"))
-
-(each [_ n (ipairs [-3 0 1 2 99])]
-  (print n (describe n)))