The zen-lsp's discuss from zen-lang

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.

Navigation: make stub

Github Actions config

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

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

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 #{}

CI: publish vs code extension automatically to marketplace

Decide on LICENSE, author names, copyright

I'll leave this to @niquola.

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)

Documentation on hover: make stub

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

Consider making some "endpoints" async for better performance

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

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.

Autocomplete: provide path into zen context given location from LSP

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

zen-lang / zen-lsp Goto Github PK

zen-lsp's Issues

Update vscode plugin README

Create zen-lsp MVP server

Navigation: make stub

Github Actions config

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

Autocomplete

Autocompletion: implement smart autocompletion

CI: publish vs code extension automatically to marketplace

Decide on LICENSE, author names, copyright

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

Documentation on hover: make stub

Support included namespaces validation

Consider making some "endpoints" async for better performance

Tests

Autocomplete: provide path into zen context given location from LSP

Recommend Projects

React

Vue.js

Typescript

TensorFlow

Django

Laravel

D3

Recommend Topics

javascript

web

server

Machine learning

Visualization

Game

Recommend Org

Facebook

Microsoft

Google

Alibaba

D3

Tencent

	(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)))))