Remove lsp4j on v1 branch

.dir-locals.el

@@ -0,0 +1,2 @@
+((clojure-mode
+  (cider-clojure-cli-aliases . "test")))

CHANGELOG.md

@@ -2,6 +2,15 @@
 
 ## Unreleased
 
+## v1.0.0
+
+- Remove lsp4j, as per https://github.com/clojure-lsp/lsp4clj/issues/8
+This is essentially a rewrite of lsp4clj. Users of lsp4clj v0.4.3 and earlier
+are encouraged to upgrade. Bug fixes for these earlier versions will be
+considered, but the lsp4j-based version of this library will not receive
+long-term support. For an example of how to use the new version of the library,
+see https://github.com/clojure-lsp/clojure-lsp/pull/1117
+
 ## v0.4.3
 
 ## v0.4.2

README.md

@@ -2,18 +2,112 @@
 
 A [Language Server Protocol](https://microsoft.github.io/language-server-protocol/) base for developing any LSP implementation in Clojure.
 
-## Server
+[![Clojars Project](https://img.shields.io/clojars/v/com.github.clojure-lsp/lsp4clj.svg)](https://clojars.org/com.github.clojure-lsp/lsp4clj)
 
-[![Clojars Project](https://img.shields.io/clojars/v/com.github.clojure-lsp/lsp4clj-server.svg)](https://clojars.org/com.github.clojure-lsp/lsp4clj-server)
+lsp4clj reads and writes from stdio, parsing JSON-RPC according to the LSP spec. It provides tools to allow server implementors to receive, process, and respond to any of the methods defined in the LSP spec, and to send their own requests and notifications to clients.
 
-The lsp4clj-server has the necessary integration with Input/Output, LSP-JSON parsing, allowing for users of this lib to just code the entrypoints of each LSP method.
+## Usage
 
-## Protocols
+### Create a server
 
-[![Clojars Project](https://img.shields.io/clojars/v/com.github.clojure-lsp/lsp4clj-protocols.svg)](https://clojars.org/com.github.clojure-lsp/lsp4clj-protocols)
+To initialize a server that will read from stdin and write to stdout:
 
-The lsp4clj-protocols contains only the protocols/interfaces for servers that want to extend the official LSP protocol to provide more features, also, it is used by lsp4clj-server itself.
+```clojure
+(lsp4clj.server/stdio-server {:in System/in, :out System/out})
+```
 
-## Known LSPs users
+The returned server will have a core.async `:log-ch`, from which you can read server logs (vectors beginning with a log level).
+
+```clojure
+(async/go-loop []
+  (when-let [[level & args] (async/<! (:log-ch server))]
+    (apply logger/warn level args)
+    (recur)))
+```
+
+### Receive messages
+
+To receive messages from a client, lsp4clj defines a pair of multimethods, `lsp4clj.server/receive-notification` and `lsp4clj.server/receive-request` that dispatch on the method name (as defined by the LSP spec) of an incoming JSON-RPC message.
+
+Server implementors should create `defmethod`s for the messages they want to process. (Other methods will be logged and responded to with a generic "Method not found" response.)
+
+These defmethods receive 3 arguments, the method name, a "context", and the `params` of the [JSON-RPC request or notification object](https://www.jsonrpc.org/specification#request_object). The params will have been converted to kebab-case keywords. Read on for an explanation of what a "context" is and how to set it.
+
+```clojure
+;; a notification; return value is ignored
+(defmethod lsp4clj.server/receive-notification "textDocument/didOpen" [_ context {:keys [text-document]}]
+  (handler/did-open context (:uri text-document) (:text text-document))
+
+;; a request; return value is convert to a response
+(defmethod lsp4clj.server/receive-request "textDocument/definition" [_ context params]
+  (->> params
+       (handler/definition context)
+       (conform-or-log ::coercer/location)))
+```
+
+The return value of requests will be converted to camelCase json and returned to the client. If the return value looks like `{:error ...}`, it is assumed to indicate an error response, and the `...` part will be set as the `error` of a [JSON-RPC error object](https://www.jsonrpc.org/specification#error_object). It is up to you to conform the `...` object (by giving it a code, message, and data.) Otherwise, the entire return value will be set as the `result` of a [JSON-RPC response object](https://www.jsonrpc.org/specification#response_object). (Message ids are handled internally by lsp4clj.)
+
+### Send messages
+
+Servers also initiate their own requests and notifications to a client. To send a notification, call `lsp4clj.server/send-notification`.
+
+```clojure
+(->> {:message message
+      :type type
+      :extra extra}
+     (conform-or-log ::coercer/show-message)
+     (lsp4clj.server/send-notification server "window/showMessage"))
+```
+
+Sending a request is similar, with `lsp4clj.server/send-request`. This method returns a request object which may be dereffed to get the client's response. Most of the time you will want to call `lsp4clj.server/deref-or-cancel`, which will send a `$/cancelRequest` to the client if a timeout is reached.
+
+```clojure
+(let [request (->> {:edit edit}
+                   (conform-or-log ::coercer/workspace-edit-params)
+                   (lsp4clj.server/send-request server "workspace/applyEdit"))
+      response (lsp4clj.server/deref-or-cancel request 10e3 ::timeout)]
+  (if (= ::timeout response)
+    (logger/error "No reponse from client after 10 seconds.")
+    response))
+```
+
+### Start and stop a server
+
+The last step is to start the server you created earlier. Use `lsp4clj.server/start`. This method accepts two arguments, the server and a "context". Whatever you provide for the context will be passed into the notification and request `defmethods` you defined earlier. This is a convenient way to make components of your system available to those methods without definining global constants. Often the context will include the server itself so that you can initiate outbound requests and notifications in reaction to inbound messages.
+
+```clojure
+(lsp4clj.server/start server {:server server, :logger logger})
+```
+
+The return of `start` is a promise that will resolve when the server shuts down, which can happen in a few ways.
+
+First, if the server's input is closed, it will shutdown too. Second, if you call `lsp4clj.server/shutdown` on it, it will shutdown.
+
+When a server shuts down it stops reading input, finishes processing the messages it has in flight, and then closes is output. (It also closes its `:log-ch` and `:trace-ch`.) As such, it should probably not be shut down until the LSP notification `exit` (as opposed to the `shutdown` request) to ensure all messages are received.
+
+## Development details
+
+As you are implementing, you may want to trace incoming and outgoing messages. Initialize the server with `:trace? true` and then read traces (strings) off its `:trace-ch`.
+
+```clojure
+(let [server (lsp4clj.server/stdio-server {:trace? true
+                                           :in System/in
+                                           :out System/out})]
+  (async/go-loop []
+    (when-let [trace (async/<! (:trace-ch server))]
+      (logger/debug trace)
+      (recur)))
+  (lsp4clj.server/start server context))
+```
+
+For testing, observe that a client is in many ways like a server, in that it sends and receives requests and notifications. That is, LSP's flavor of JSON-RPC is bi-directional. As such, you may be able to use some of lsp4clj's tools to build a mock client for testing. See `integration.client` in `clojure-lsp` for one such example.
+
+You may also find `lsp4clj.server/chan-server` a useful alternative to `stdio-server`. This server reads and writes off channels, insead of stdio streams.
+
+## Caveats
+
+You must not print to stdout while a server is running. This will corrupt its output stream and clients will receive malformed messages. To protect a block of code from writing to stdout, wrap it with `lsp4clj.server/discarding-stdout`. The `receive-notification` and `receive-request` multimethods are already protected this way, but tasks started outside of these multimethods need this protection added. See https://github.com/clojure-lsp/lsp4clj/issues/1 for future work on avoiding this problem.
+
+## Known lsp4clj users
 
 - [clojure-lsp](https://clojure-lsp.io/): A Clojure LSP server implementation.

bb.edn

@@ -1,17 +1,13 @@
 {:paths ["scripts"]
  :min-bb-version "0.4.0"
  :tasks {:requires ([babashka.fs :as fs])
-         clean (do (fs/delete-tree "server/target")
-                   (fs/delete-tree "server/lsp4clj-server.jar")
-                   (fs/delete-tree "protocols/target")
-                   (fs/delete-tree "protocols/lsp4clj-protocols.jar"))
-         test (shell {:dir "server"} "clojure -M:test")
+         clean (do (fs/delete-tree "target")
+                   (fs/delete-tree "lsp4clj.jar"))
+         test (shell "clojure -M:test")
 
-         server-pom (shell {:dir "server"} "clojure -T:build pom")
-         protocols-pom (shell {:dir "protocols"} "clojure -T:build pom")
+         pom (shell "clojure -T:build pom")
 
-         server-jar (shell {:dir "server"} "clojure -T:build jar")
-         protocols-jar (shell {:dir "protocols"} "clojure -T:build jar")
+         jar (shell "clojure -T:build jar")
 
          lint (do (shell "clojure-lsp format --dry")
                   (shell "clojure-lsp clean-ns --dry")
@@ -22,5 +18,4 @@
          ;; Receive arg without v
          tag lsp4clj.ci/tag
 
-         deploy-clojars-server (shell {:dir "server"} "clojure -T:build deploy-clojars")
-         deploy-clojars-protocols (shell {:dir "protocols"} "clojure -T:build deploy-clojars")}}
+         deploy-clojars (shell "clojure -T:build deploy-clojars")}}

protocols/build.clj → build.clj

@@ -3,7 +3,7 @@
    [clojure.string :as string]
    [clojure.tools.build.api :as b]))
 
-(def lib 'com.github.clojure-lsp/lsp4clj-protocols)
+(def lib 'com.github.clojure-lsp/lsp4clj)
 (def jar-file (format "target/%s.jar" (name lib)))
 
 (def current-version (string/trim (slurp "resources/LSP4CLJ_VERSION")))

deps.edn

@@ -1,11 +1,13 @@
-{:paths []
- :aliases {:dev {:extra-paths ["protocols/src"
-                               "server/src"]
-                 :extra-deps {lsp4clj/server {:local/root "server"}
-                              lsp4clj/protocols {:local/root "protocols"}
-                              io.github.clojure/tools.build {:git/url "https://github.com/clojure/tools.build.git"
-                                                             :tag "v0.8.1"
-                                                             :sha "7d40500"}}}
-           :test {:extra-deps {lambdaisland/kaocha {:mvn/version "1.64.1010"}}
-                  :extra-paths ["server/test"]
-                  :main-opts ["-m" "kaocha.runner"]}}}
+{:deps {org.clojure/clojure {:mvn/version "1.11.1"}
+        org.clojure/core.async {:mvn/version "1.5.648"}
+        camel-snake-kebab/camel-snake-kebab {:mvn/version "0.4.3"}
+        cheshire/cheshire {:mvn/version "5.11.0"} }
+ :paths ["src" "resources"]
+ :aliases {:test {:extra-deps {lambdaisland/kaocha {:mvn/version "1.64.1010"}}
+                  :extra-paths ["test"]
+                  :main-opts ["-m" "kaocha.runner"]}
+           :build {:extra-paths ["resources"]
+                   :deps {io.github.clojure/tools.build {:git/tag "v0.8.1"
+                                                         :git/sha "7d40500"}
+                          slipset/deps-deploy {:mvn/version "0.2.0"}}
+                   :ns-default build}}}

pom.properties

@@ -0,0 +1,5 @@
+# Generated by org.clojure/tools.build
+# Thu Jul 14 13:48:53 PDT 2022
+version=1.0.0
+groupId=com.github.clojure-lsp
+artifactId=lsp4clj

protocols/pom.xml → pom.xml

@@ -3,16 +3,37 @@
   <modelVersion>4.0.0</modelVersion>
   <packaging>jar</packaging>
   <groupId>com.github.clojure-lsp</groupId>
-  <artifactId>lsp4clj-protocols</artifactId>
-  <version>0.4.3</version>
-  <name>lsp4clj-protocols</name>
+  <artifactId>lsp4clj</artifactId>
+  <version>1.0.0</version>
+  <name>lsp4clj</name>
   <dependencies>
     <dependency>
       <groupId>org.clojure</groupId>
       <artifactId>clojure</artifactId>
       <version>1.11.1</version>
     </dependency>
+    <dependency>
+      <groupId>cheshire</groupId>
+      <artifactId>cheshire</artifactId>
+      <version>5.11.0</version>
+    </dependency>
+    <dependency>
+      <groupId>camel-snake-kebab</groupId>
+      <artifactId>camel-snake-kebab</artifactId>
+      <version>0.4.3</version>
+    </dependency>
+    <dependency>
+      <groupId>org.clojure</groupId>
+      <artifactId>core.async</artifactId>
+      <version>1.5.648</version>
+    </dependency>
   </dependencies>
+  <repositories>
+    <repository>
+      <id>clojars</id>
+      <url>https://repo.clojars.org/</url>
+    </repository>
+  </repositories>
   <build>
     <sourceDirectory>src</sourceDirectory>
     <resources>
@@ -21,16 +42,10 @@
       </resource>
     </resources>
   </build>
-  <repositories>
-    <repository>
-      <id>clojars</id>
-      <url>https://repo.clojars.org/</url>
-    </repository>
-  </repositories>
   <scm>
     <url>https://github.com/clojure-lsp/lsp4clj</url>
     <connection>scm:git:git://github.com/clojure-lsp/lsp4clj.git</connection>
     <developerConnection>scm:git:ssh://git@github.com/clojure-lsp/lsp4clj.git</developerConnection>
-    <tag>0.4.3</tag>
+    <tag>v1.0.0</tag>
   </scm>
 </project>