kapusta 0.13.2 → 0.14.0

data/lib/kapusta/lsp/workspace_index.rb

@@ -65,7 +65,7 @@ module Kapusta
         result = []
         @entries.each do |uri, entry|
           entry.walker.bindings.each do |b|
-            next unless %i[module class].include?(b.kind)
+            next unless Compiler::Language.header_scope?(b.kind)
 
             segs = b.sym.dotted? ? b.sym.segments : [b.sym.name]
             result << [uri, b] if segs == prefix
@@ -104,7 +104,7 @@ module Kapusta
       def constant_definition_with_prefix?(prefix, except_prefix: nil)
         @entries.any? do |_uri, entry|
           entry.walker.bindings.any? do |b|
-            next false unless %i[module class].include?(b.kind)
+            next false unless Compiler::Language.header_scope?(b.kind)
             next false if except_prefix && matches_prefix?(b.sym, except_prefix)
 
             matches_prefix?(b.sym, prefix)
@@ -147,7 +147,7 @@ module Kapusta
         @entries.each do |uri, entry|
           occs = []
           entry.walker.bindings.each do |b|
-            next unless %i[module class].include?(b.kind)
+            next unless Compiler::Language.header_scope?(b.kind)
 
             occs << b if matches_prefix?(b.sym, prefix)
           end
@@ -171,7 +171,13 @@ module Kapusta
       end
 
       def matches_prefix?(sym, prefix)
-        segs = sym.dotted? ? sym.segments : [sym.name]
+        segs = if sym.dotted?
+                 sym.segments
+               elsif sym.colonized?
+                 sym.colon_segments
+               else
+                 [sym.name]
+               end
         return false if segs.length < prefix.length
 
         segs[0...prefix.length] == prefix
@@ -194,7 +200,13 @@ module Kapusta
       end
 
       def first_segment_capitalized?(sym)
-        first = sym.dotted? ? sym.segments.first : sym.name
+        first = if sym.dotted?
+                  sym.segments.first
+                elsif sym.colonized?
+                  sym.colon_segments.first
+                else
+                  sym.name
+                end
         first.match?(/\A[A-Z]/)
       end
 

data/lib/kapusta/reader.rb

@@ -286,7 +286,7 @@ module Kapusta
         break unless token.start_with?('.') && token.length > 1
 
         token[1..].split('.').each do |name|
-          current = List.new([Sym.new(':'), current, Kapusta.kebab_to_snake(name).to_sym])
+          current = List.new([Sym.new('.'), current, Kapusta.kebab_to_snake(name).to_sym])
         end
       end
 
@@ -345,7 +345,9 @@ module Kapusta
         raise reader_error(:bad_shorthand, source_position) unless value.is_a?(Sym)
 
         key = Kapusta.kebab_to_snake(value.name).to_sym
-        [key, value]
+        pair = [key, value]
+        pair.define_singleton_method(:shorthand?) { true }
+        pair
       else
         [item, value]
       end

data/lib/kapusta/version.rb

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

data/lib/kapusta.rb

@@ -11,6 +11,8 @@ require_relative 'kapusta/compiler'
 
 module Kapusta
   @loaded_kapusta_features = {}
+  LOADING_KAPUSTA_FEATURE = Object.new
+  private_constant :LOADING_KAPUSTA_FEATURE
 
   def self.eval(source, path: '(eval)', **_opts)
     install!
@@ -29,12 +31,15 @@ module Kapusta
 
   def self.require(feature, relative_to: nil)
     install!
-    feature = feature.to_s
+    feature = require_feature_name(feature)
     local_path = resolve_require_path(feature, relative_to:)
 
     return require_kapusta_file(local_path) if local_path&.end_with?('.kap')
     return Kernel.require(local_path) if local_path
 
+    kap_path = resolve_load_path_kapusta_feature(feature, relative_to:)
+    return require_kapusta_file(kap_path) if kap_path
+
     Kernel.require(feature)
   end
 
@@ -99,19 +104,47 @@ module Kapusta
     candidates.find { |candidate| File.file?(candidate) }
   end
 
+  def self.require_feature_name(feature)
+    feature.is_a?(Symbol) ? feature.to_s.tr('.', '/') : feature.to_s
+  end
+
+  def self.resolve_load_path_kapusta_feature(feature, relative_to:)
+    return if local_feature?(feature)
+
+    load_paths = [require_base_dir(relative_to), *$LOAD_PATH].uniq
+    load_paths.each do |load_path|
+      candidate = existing_kapusta_feature_path(File.expand_path(feature, load_path))
+      return candidate if candidate
+    end
+    nil
+  end
+
+  def self.existing_kapusta_feature_path(path)
+    candidates = File.extname(path).empty? ? ["#{path}.kap"] : [path]
+    candidates.find { |candidate| File.file?(candidate) && candidate.end_with?('.kap') }
+  end
+
   def self.require_kapusta_file(path)
     expanded = File.realpath(path)
-    return false if @loaded_kapusta_features[expanded]
+    if @loaded_kapusta_features.key?(expanded)
+      cached = @loaded_kapusta_features[expanded]
+      return false if cached.equal?(LOADING_KAPUSTA_FEATURE)
+
+      return cached
+    end
 
-    @loaded_kapusta_features[expanded] = true
-    dofile(expanded)
+    @loaded_kapusta_features[expanded] = LOADING_KAPUSTA_FEATURE
+    value = dofile(expanded)
+    @loaded_kapusta_features[expanded] = value
     $LOADED_FEATURES << expanded unless $LOADED_FEATURES.include?(expanded)
-    true
+    value
   rescue StandardError, ScriptError
     @loaded_kapusta_features.delete(expanded) if expanded
     raise
   end
 
   private_class_method :resolve_require_path, :local_feature?, :require_base_dir,
-                       :existing_feature_path, :require_kapusta_file, :resolve_kap_relative
+                       :existing_feature_path, :require_feature_name,
+                       :resolve_load_path_kapusta_feature, :existing_kapusta_feature_path,
+                       :require_kapusta_file, :resolve_kap_relative
 end

data/spec/cli_spec.rb

@@ -138,4 +138,17 @@ RSpec.describe Kapusta::CLI do
     expect(status.success?).to eq(true), stderr
     expect(stdout).to eq("kapusta #{Kapusta::VERSION}\n")
   end
+
+  it 'reports kapusta-ls lint diagnostics for an unknown class body form' do
+    Dir.mktmpdir do |dir|
+      path = File.join(dir, 'broken.kap')
+      File.write(path, "(class BankAccount)\n\n(n initialize [owner balance]\n  owner)\n\n(end)\n")
+
+      stdout, stderr, status = Open3.capture3(RbConfig.ruby, File.expand_path('../exe/kapusta-ls', __dir__),
+                                              '--lint', path)
+
+      expect(status.success?).to eq(false), stdout
+      expect(stderr).to include('class body form must be a declaration or known special form: n')
+    end
+  end
 end

data/spec/examples_errors_spec.rb

@@ -34,7 +34,9 @@ RSpec.describe 'examples-errors' do
 
   it 'bad-multisym.kap' do
     expect(run_error_example('bad-multisym.kap'))
-      .to eq("bad-multisym.kap:1:8: bad multisym: unbound.foo\n")
+      .to eq('bad-multisym.kap:1:8: bad multisym: unbound.foo; unresolved root unbound; ' \
+             'bind unbound first, use a capitalized constant path, ' \
+             "or call a method on an explicit receiver\n")
   end
 
   it 'bad-set-target.kap' do

data/spec/examples_spec.rb

@@ -226,6 +226,10 @@ RSpec.describe 'examples' do
     expect(run_example('count-effects.kap')).to eq("1\n2\n")
   end
 
+  it 'count-items-matching-rule.kap' do
+    expect(run_example('count-items-matching-rule.kap')).to eq("2\n1\n1\n")
+  end
+
   it 'max-achievable.kap' do
     expect(run_example('max-achievable.kap')).to eq("6\n7\n10\n")
   end
@@ -250,21 +254,6 @@ RSpec.describe 'examples' do
     OUT
   end
 
-  it 'describe.kap' do
-    expect(run_example('describe.kap')).to eq(<<~OUT)
-      -3
-      "negative"
-      0
-      "zero"
-      1
-      "one"
-      2
-      "many"
-      99
-      "many"
-    OUT
-  end
-
   it 'destructure.kap' do
     expect(run_example('destructure.kap')).to eq(<<~OUT)
       6
@@ -352,6 +341,10 @@ RSpec.describe 'examples' do
     expect(run_example('gcd.kap')).to eq("12\n6\n")
   end
 
+  it 'good-pairs.kap' do
+    expect(run_example('good-pairs.kap')).to eq("4\n6\n0\n")
+  end
+
   it 'greet.kap' do
     expect(run_example('greet.kap', argv: ['Ada'])).to eq(<<~OUT)
       "Hello, Ada!"
@@ -379,6 +372,10 @@ RSpec.describe 'examples' do
     expect(run_example('leap-year.kap')).to eq("true\n")
   end
 
+  it 'left-right-difference.kap' do
+    expect(run_example('left-right-difference.kap')).to eq("true\n")
+  end
+
   it 'length-of-last-word.kap' do
     expect(run_example('length-of-last-word.kap')).to eq("5\n4\n6\n")
   end
@@ -390,6 +387,17 @@ RSpec.describe 'examples' do
     OUT
   end
 
+  it 'minimum-start-value.kap' do
+    expect(run_example('minimum-start-value.kap')).to eq(<<~OUT)
+      5
+      2
+      1
+      3
+      5
+      -4
+    OUT
+  end
+
   it 'module-header.kap' do
     expect(run_example('module-header.kap')).to eq(<<~OUT)
       "Hello, Ada!"
@@ -426,6 +434,14 @@ RSpec.describe 'examples' do
     OUT
   end
 
+  it 'range-width.kap' do
+    expect(run_example('range-width.kap')).to eq(<<~OUT)
+      8
+      0
+      11
+    OUT
+  end
+
   it 'record.kap' do
     expect(run_example('record.kap')).to eq(<<~OUT)
       "Ada / engineer / ruby, lisp"
@@ -449,6 +465,10 @@ RSpec.describe 'examples' do
     OUT
   end
 
+  it 'running-sum.kap' do
+    expect(run_example('running-sum.kap')).to eq("true\ntrue\ntrue\n")
+  end
+
   it 'kwargs.kap' do
     expect(run_example('kwargs.kap')).to eq(<<~OUT)
       "Ada has 3 tasks"
@@ -558,6 +578,14 @@ RSpec.describe 'examples' do
     expect(run_example('sum.kap')).to eq("100\n")
   end
 
+  it 'summary-ranges.kap' do
+    expect(run_example('summary-ranges.kap')).to eq(<<~OUT)
+      "0->2|4->5|7"
+      "0|2->4|6|8->9"
+      "empty="
+    OUT
+  end
+
   it 'tset.kap' do
     person = { name: 'Ada', city: 'Amsterdam' }
     expect(run_example('tset.kap')).to eq("#{person.inspect}\n#{'Amsterdam'.inspect}\n")
@@ -571,6 +599,10 @@ RSpec.describe 'examples' do
     expect(run_example('two-sum-hash.kap')).to eq("[0, 1]\n[1, 2]\nnil\n")
   end
 
+  it 'underground-system.kap' do
+    expect(run_example('underground-system.kap')).to eq("11\n14\n")
+  end
+
   it 'bst-iterator.kap' do
     expect(run_example('bst-iterator.kap')).to eq(<<~OUT)
       3
@@ -715,6 +747,26 @@ RSpec.describe 'examples' do
     expect(run_example('macros-import-whole.kap')).to eq("7\n")
   end
 
+  it 'require-local.kap' do
+    expect(run_example('require-local.kap')).to eq(<<~OUT)
+      "serve"
+      "--port 3000"
+      "usage: kapusta <command> [options]"
+    OUT
+  end
+
+  it 'require-module.kap' do
+    expect(run_example('require-module.kap')).to eq(<<~OUT)
+      "deploy -> production"
+    OUT
+  end
+
+  it 'require-module-local.kap' do
+    expect(run_example('require-module-local.kap')).to eq(<<~OUT)
+      "deploy -> production"
+    OUT
+  end
+
   it 'parking-system.kap' do
     expect(run_example('parking-system.kap')).to eq("true\ntrue\nfalse\nfalse\n")
   end

data/spec/formatter_spec.rb

@@ -98,6 +98,29 @@ RSpec.describe Kapusta::Formatter do
     end
   end
 
+  it 'checks kapm macro modules with quasiquoted function templates' do
+    Dir.mktmpdir do |dir|
+      path = File.join(dir, 'sample.kapm')
+      File.write(path, <<~KAP)
+        (fn defcommand [name args runtime-args body1 & body]
+          `(fn ,name
+             ,args
+
+             (fn ,runtime-args
+               ,body1
+               ,(unpack body))))
+
+        {: defcommand}
+      KAP
+
+      error_output = capture_stderr do
+        expect(described_class.new(['--check', path]).run).to eq(0)
+      end
+
+      expect(error_output).to eq('')
+    end
+  end
+
   it 'reads stdin when the input path is -' do
     output = with_stdin("(let [name (or (. ARGV 0) \"world\")](puts (.. \"Hello, \" name \"!\")))\n") do
       capture_stdout do
@@ -271,6 +294,229 @@ RSpec.describe Kapusta::Formatter do
     end
   end
 
+  it 'keeps short vector call arguments on the call line' do
+    Dir.mktmpdir do |dir|
+      path = File.join(dir, 'sample.kap')
+      File.write(path, <<~KAP)
+        (fn range-label [lo hi]
+          (join ""
+            [(.. lo) "->" (.. hi)]))
+      KAP
+
+      output = capture_stdout do
+        expect(described_class.new([path]).run).to eq(0)
+      end
+
+      expect(output).to eq(<<~KAP)
+        (fn range-label [lo hi]
+          (join "" [(.. lo) "->" (.. hi)]))
+      KAP
+    end
+  end
+
+  it 'keeps short local hash values on the local line' do
+    Dir.mktmpdir do |dir|
+      path = File.join(dir, 'sample.kap')
+      File.write(path, <<~KAP)
+        (local rule-keys
+          {"type" :type
+           "color" :color
+           "name" :name})
+      KAP
+
+      output = capture_stdout do
+        expect(described_class.new([path]).run).to eq(0)
+      end
+
+      expect(output).to eq(<<~KAP)
+        (local rule-keys {"type" :type "color" :color "name" :name})
+      KAP
+    end
+  end
+
+  it 'hangs hash-first call arguments under the first argument' do
+    Dir.mktmpdir do |dir|
+      path = File.join(dir, 'sample.kap')
+      File.write(path, <<~KAP)
+        (local check (fn [expected actual] (= expected actual)))
+        (local scroll-state (fn [lines visible offset] [lines visible offset]))
+
+        (check {:preview-offset 0 :preview-total 3 :preview-visible 5}
+          (scroll-state ["a" "b" "c"] 5 10))
+      KAP
+
+      output = capture_stdout do
+        expect(described_class.new([path]).run).to eq(0)
+      end
+
+      expect(output).to eq(<<~KAP)
+        (local check (fn [expected actual] (= expected actual)))
+        (local scroll-state (fn [lines visible offset] [lines visible offset]))
+
+        (check {:preview-offset 0 :preview-total 3 :preview-visible 5}
+               (scroll-state ["a" "b" "c"] 5 10))
+      KAP
+    end
+  end
+
+  it 'packs overflowing call arguments before hanging the rest' do
+    Dir.mktmpdir do |dir|
+      path = File.join(dir, 'sample.kap')
+      File.write(path, <<~KAP)
+        (local preview {})
+        (local state {})
+
+        (preview.apply-horizontal-scroll-limit state ["abcdefghijklmnopqrstuvwxyz"] 20 true)
+      KAP
+
+      output = capture_stdout do
+        expect(described_class.new([path]).run).to eq(0)
+      end
+
+      expect(output).to eq(<<~KAP)
+        (local preview {})
+        (local state {})
+
+        (preview.apply-horizontal-scroll-limit state ["abcdefghijklmnopqrstuvwxyz"] 20
+                                               true)
+      KAP
+    end
+  end
+
+  it 'wraps long call values in let bindings with hanging arguments' do
+    Dir.mktmpdir do |dir|
+      path = File.join(dir, 'sample.kap')
+      File.write(path, <<~KAP)
+        (local entries [])
+        (local update {})
+
+        (let [state (update.init "HEAD" entries {:version 1 :reviews {}} "scope-long" "src-long-name")]
+          state)
+      KAP
+
+      output = capture_stdout do
+        expect(described_class.new([path]).run).to eq(0)
+      end
+
+      expect(output).to eq(<<~KAP)
+        (local entries [])
+        (local update {})
+
+        (let [state (update.init "HEAD" entries {:version 1 :reviews {}} "scope-long"
+                                 "src-long-name")]
+          state)
+      KAP
+    end
+  end
+
+  it 'keeps multiline hash call arguments hanging in let bindings' do
+    Dir.mktmpdir do |dir|
+      path = File.join(dir, 'sample.kap')
+      File.write(path, <<~KAP)
+        (local preview-key {})
+
+        (let [old-key (preview-key.for-entry "HEAD" {:status "M" :kind "M" :path "old.rb" :reviewed false})]
+          old-key)
+      KAP
+
+      output = capture_stdout do
+        expect(described_class.new([path]).run).to eq(0)
+      end
+
+      expect(output).to eq(<<~KAP)
+        (local preview-key {})
+
+        (let [old-key (preview-key.for-entry "HEAD"
+                                             {:status "M"
+                                              :kind "M"
+                                              :path "old.rb"
+                                              :reviewed false})]
+          old-key)
+      KAP
+    end
+  end
+
+  it 'separates compound items in multiline vectors' do
+    Dir.mktmpdir do |dir|
+      path = File.join(dir, 'sample.kap')
+      File.write(path, <<~KAP)
+        (local tree {})
+
+        (fn entry [status path]
+          [status path])
+
+        (fn check [expected actual]
+          [expected actual])
+
+        (fn test-tree []
+          (let [rows (tree.rows [(entry "A" "script/shorthand_branch.sh") (entry "M"
+                                                                            "spec/lib/epoxy/version_branch_validation_spec.rb")
+                                 (entry "M" "spec/lib/direct_spec.rb") (entry "M"
+                                                                         "spec/lib/tasks/helpers/commit_validator_spec.rb")])]
+            (check [{:type :folder :depth 0 :name "script/" :path "script"}
+                    {:type :file :depth 1 :name "shorthand_branch.sh" :entry-index 1}
+                    {:type :folder :depth 1 :name "epoxy/" :path "spec/lib/epoxy"} {:type :file
+                                                                                    :depth 2
+                                                                                    :name "version_branch_validation_spec.rb"
+                                                                                    :entry-index 2}]
+              rows)))
+      KAP
+
+      output = capture_stdout do
+        expect(described_class.new([path]).run).to eq(0)
+      end
+
+      expect(output).to eq(<<~KAP)
+        (local tree {})
+
+        (fn entry [status path]
+          [status path])
+
+        (fn check [expected actual]
+          [expected actual])
+
+        (fn test-tree []
+          (let [rows (tree.rows [(entry "A" "script/shorthand_branch.sh")
+                                 (entry "M"
+                                        "spec/lib/epoxy/version_branch_validation_spec.rb")
+                                 (entry "M" "spec/lib/direct_spec.rb")
+                                 (entry "M"
+                                        "spec/lib/tasks/helpers/commit_validator_spec.rb")])]
+            (check [{:type :folder :depth 0 :name "script/" :path "script"}
+                    {:type :file :depth 1 :name "shorthand_branch.sh" :entry-index 1}
+                    {:type :folder :depth 1 :name "epoxy/" :path "spec/lib/epoxy"}
+                    {:type :file
+                     :depth 2
+                     :name "version_branch_validation_spec.rb"
+                     :entry-index 2}]
+              rows)))
+      KAP
+    end
+  end
+
+  it 'hangs function values in set forms' do
+    Dir.mktmpdir do |dir|
+      path = File.join(dir, 'sample.kap')
+      File.write(path, <<~KAP)
+        (local loader {})
+        (set loader.preview-output
+          (fn [...]
+            (error "scroll should not load preview lines")))
+      KAP
+
+      output = capture_stdout do
+        expect(described_class.new([path]).run).to eq(0)
+      end
+
+      expect(output).to eq(<<~KAP)
+        (local loader {})
+        (set loader.preview-output
+             (fn [...]
+               (error "scroll should not load preview lines")))
+      KAP
+    end
+  end
+
   it 'preserves nil-valued let bindings before function bindings' do
     Dir.mktmpdir do |dir|
       path = File.join(dir, 'sample.kap')

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(