The zen-lsp from zen-lang

Consider making some "endpoints" async for better performance

Right now it was implemented quickly with (CompletedFuture value) but this is synchronous.

Github Actions config

build and release lsp uberjar
publish automatically the vscode plugin to the vscode marketplace

Autocompletion: implement smart autocompletion

We need more smart-autocompletion, depending on context.

complete keys for schema, bassed on current type
complete keys for schema, based on current type confirmation (zen/vector confirms zen/coll)
complete symbols from current ns, imported ns, zen.edn
complete tags when cursor in :zen/tags #{}
complete schemas when cursor in :confirms #{}

Documentation on hover: make stub

Update vscode plugin README

https://marketplace.visualstudio.com/items?itemName=zen-lang.zen-lsp

Support included namespaces validation

Example clojure test with the expected errors: zen-lsp-test.tar.gz
If opened in vscode with zen-lsp plugin, more errors found than expected

use read-ns rather than manually reading every zen file on init

It has zen.core/read-ns to process import, which uses clojure.java.io/resource to locate files, (thus it searches in classpath)

Tests

@niquola I'd like to write some unit tests for this part of the code:

zen-lsp/server/src/zen_lang/lsp_server/impl/server.clj

Lines 109 to 138 in 38037ae

    
           (defn error->finding [edn-node error] 
        
             (let [message (:message error) 
        
                   ;; path (:path error) 
        
                   resource (:resource error) 
        
                   resource-path (some-> resource name symbol) 
        
                   path (cons resource-path (:path error)) 
        
                   key? (str/includes? message "unknown key") 
        
                   loc (get-location edn-node path key?) 
        
                   finding (assoc loc :message message :level :warning)] 
        
               finding)) 
        
           (defn lint! [text uri] 
        
             (when-not (str/ends-with? uri ".calva/output-window/output.calva-repl") 
        
               (let [_lang (uri->lang uri) 
        
                     path (-> (java.net.URI. uri) 
        
                              (.getPath)) 
        
                     edn (e/parse-string text) 
        
                     ctx (zen/new-context {:unsafe true}) 
        
                     _ (store/load-ns ctx edn {:zen/file path}) 
        
                     errors (:errors @ctx) 
        
                     edn-node (p/parse-string text) 
        
                     findings (map #(error->finding edn-node %) errors) 
        
                     {:keys [:findings]} {:findings findings} 
        
                     lines (str/split text #"\r?\n") 
        
                     diagnostics (vec (keep #(finding->Diagnostic lines %) findings))] 
        
                 (debug "publishing diagnostics") 
        
                 (.publishDiagnostics ^LanguageClient @proxy-state 
        
                                      (PublishDiagnosticsParams. 
        
                                       uri 
        
                                       diagnostics)))))

In the tests we can capture the correct behavior given a path + text (EDN string) and the expected lint warnings (and expected locations).

Currently I've been experimenting with this bit of code:

which seems to work well, but as we make changes, tests will ensure that it will remain working.

Therefore I need more test cases + expected outputs.

Research and document how to run uberjar in emacs with lsp-mode

Autocomplete

We can start here:

zen ctx contains key called :ns and :symbols and this can be used for autocompletions
call this function from lsp mode

Possible improvements:

zen-core will provide a function that returns autocompletions, given the last valid zen edn file and location and/or path like [:foo bar baz] into the EDN

Autocomplete: provide path into zen context given location from LSP

Also provide the last valid namespace (hash-map).

CI: publish vs code extension automatically to marketplace

Decide on LICENSE, author names, copyright

I'll leave this to @niquola.

Create zen-lsp MVP server

Created the initial setup for the zen-lsp server.

@niquola Let's create some more issues to work on next. We could start with some simple linting for single files or index a project (need more info how this should work) first and then do some linting.

	(defn error->finding [edn-node error]
	(let [message (:message error)
	;; path (:path error)
	resource (:resource error)
	resource-path (some-> resource name symbol)
	path (cons resource-path (:path error))
	key? (str/includes? message "unknown key")
	loc (get-location edn-node path key?)
	finding (assoc loc :message message :level :warning)]
	finding))

	(defn lint! [text uri]
	(when-not (str/ends-with? uri ".calva/output-window/output.calva-repl")
	(let [_lang (uri->lang uri)
	path (-> (java.net.URI. uri)
	(.getPath))
	edn (e/parse-string text)
	ctx (zen/new-context {:unsafe true})
	_ (store/load-ns ctx edn {:zen/file path})
	errors (:errors @ctx)
	edn-node (p/parse-string text)
	findings (map #(error->finding edn-node %) errors)
	{:keys [:findings]} {:findings findings}
	lines (str/split text #"\r?\n")
	diagnostics (vec (keep #(finding->Diagnostic lines %) findings))]
	(debug "publishing diagnostics")
	(.publishDiagnostics ^LanguageClient @proxy-state
	(PublishDiagnosticsParams.
	uri
	diagnostics)))))

zen-lang / zen-lsp Goto Github PK

zen-lsp's People

Contributors

Stargazers

Watchers

Forkers

zen-lsp's Issues

Recommend Projects

Recommend Topics

Recommend Org