Description : A functional testing framework for LSP servers.
Maintainer : luke_lau@icloud.com
Stability : experimental
-Portability : POSIX
+Portability : non-portable
Provides the framework to start functionally testing
<https://github.com/Microsoft/language-server-protocol Language Server Protocol servers>.
, module Language.Haskell.LSP.Test.Parsing
-- * Utilities
-- | Quick helper functions for common tasks.
+
-- ** Initialization
, initializeResponse
-- ** Documents
, openDoc
+ , openDoc'
, closeDoc
+ , changeDoc
, documentContents
, getDocumentEdit
, getDocUri
, formatRange
-- ** Edits
, applyEdit
+ -- ** Code lenses
+ , getCodeLenses
) where
import Control.Applicative.Combinators
import Language.Haskell.LSP.Test.Parsing
import Language.Haskell.LSP.Test.Session
import Language.Haskell.LSP.Test.Server
+import System.Environment
import System.IO
import System.Directory
import System.FilePath
-import qualified Yi.Rope as Rope
+import qualified Data.Rope.UTF16 as Rope
-- | Starts a new session.
--
-> FilePath -- ^ The filepath to the root directory for the session.
-> Session a -- ^ The session to run.
-> IO a
-runSessionWithConfig config serverExe caps rootDir session = do
+runSessionWithConfig config' serverExe caps rootDir session = do
pid <- getCurrentProcessID
absRootDir <- canonicalizePath rootDir
+ config <- envOverrideConfig config'
+
let initializeParams = InitializeParams (Just pid)
(Just $ T.pack absRootDir)
(Just $ filePathToUri absRootDir)
caps
(Just TraceOff)
Nothing
- withServer serverExe (logStdErr config) $ \serverIn serverOut _ ->
- runSessionWithHandles serverIn serverOut listenServer config caps rootDir $ do
-
+ withServer serverExe (logStdErr config) $ \serverIn serverOut serverProc ->
+ runSessionWithHandles serverIn serverOut serverProc listenServer config caps rootDir exitServer $ do
-- Wrap the session around initialize and shutdown calls
initRspMsg <- request Initialize initializeParams :: Session InitializeResponse
initRspVar <- initRsp <$> ask
liftIO $ putMVar initRspVar initRspMsg
-
sendNotification Initialized InitializedParams
case lspConfig config of
Nothing -> return ()
-- Run the actual test
- result <- session
-
- sendNotification Exit ExitParams
-
- return result
+ session
where
- -- | Listens to the server output, makes sure it matches the record and
- -- signals any semaphores
+ -- | Asks the server to shutdown and exit politely
+ exitServer :: Session ()
+ exitServer = request_ Shutdown (Nothing :: Maybe Value) >> sendNotification Exit ExitParams
+
+ -- | Listens to the server output until the shutdown ack,
+ -- makes sure it matches the record and signals any semaphores
listenServer :: Handle -> SessionContext -> IO ()
listenServer serverOut context = do
msgBytes <- getNextMessage serverOut
let msg = decodeFromServerMsg reqMap msgBytes
writeChan (messageChan context) (ServerMessage msg)
- listenServer serverOut context
+ case msg of
+ (RspShutdown _) -> return ()
+ _ -> listenServer serverOut context
+
+ -- | Check environment variables to override the config
+ envOverrideConfig :: SessionConfig -> IO SessionConfig
+ envOverrideConfig cfg = do
+ logMessages' <- fromMaybe (logMessages cfg) <$> checkEnv "LSP_TEST_LOG_MESSAGES"
+ logStdErr' <- fromMaybe (logStdErr cfg) <$> checkEnv "LSP_TEST_LOG_STDERR"
+ return $ cfg { logMessages = logMessages', logStdErr = logStdErr' }
+ where checkEnv :: String -> IO (Maybe Bool)
+ checkEnv s = fmap (const True) <$> lookupEnv s
-- | The current text contents of a document.
documentContents :: TextDocumentIdentifier -> Session T.Text
documentContents doc = do
vfs <- vfs <$> get
- let file = vfs Map.! (doc ^. uri)
+ let file = vfsMap vfs Map.! toNormalizedUri (doc ^. uri)
return $ Rope.toText $ Language.Haskell.LSP.VFS._text file
-- | Parses an ApplyEditRequest, checks that it is for the passed document
n :: DidOpenTextDocumentNotification
n = NotificationMessage "2.0" TextDocumentDidOpen params'
oldVFS <- vfs <$> get
- newVFS <- liftIO $ openVFS oldVFS n
+ let (newVFS,_) = openVFS oldVFS n
modify (\s -> s { vfs = newVFS })
sendMessage n
n :: DidCloseTextDocumentNotification
n = NotificationMessage "2.0" TextDocumentDidClose params'
oldVFS <- vfs <$> get
- newVFS <- liftIO $ closeVFS oldVFS n
+ let (newVFS,_) = closeVFS oldVFS n
+ modify (\s -> s { vfs = newVFS })
+ sendMessage n
+
+sendNotification TextDocumentDidChange params = do
+ let params' = fromJust $ decode $ encode params
+ n :: DidChangeTextDocumentNotification
+ n = NotificationMessage "2.0" TextDocumentDidChange params'
+ oldVFS <- vfs <$> get
+ let (newVFS,_) = changeFromClientVFS oldVFS n
modify (\s -> s { vfs = newVFS })
sendMessage n
-- | Opens a text document and sends a notification to the client.
openDoc :: FilePath -> String -> Session TextDocumentIdentifier
openDoc file languageId = do
- item <- getDocItem file languageId
- sendNotification TextDocumentDidOpen (DidOpenTextDocumentParams item)
- TextDocumentIdentifier <$> getDocUri file
- where
- -- | Reads in a text document as the first version.
- getDocItem :: FilePath -- ^ The path to the text document to read in.
- -> String -- ^ The language ID, e.g "haskell" for .hs files.
- -> Session TextDocumentItem
- getDocItem file languageId = do
context <- ask
let fp = rootDir context </> file
contents <- liftIO $ T.readFile fp
- return $ TextDocumentItem (filePathToUri fp) (T.pack languageId) 0 contents
+ openDoc' file languageId contents
+
+-- | This is a variant of `openDoc` that takes the file content as an argument.
+openDoc' :: FilePath -> String -> T.Text -> Session TextDocumentIdentifier
+openDoc' file languageId contents = do
+ context <- ask
+ let fp = rootDir context </> file
+ uri = filePathToUri fp
+ item = TextDocumentItem uri (T.pack languageId) 0 contents
+ sendNotification TextDocumentDidOpen (DidOpenTextDocumentParams item)
+ pure $ TextDocumentIdentifier uri
-- | Closes a text document and sends a notification to the client.
closeDoc :: TextDocumentIdentifier -> Session ()
let params = DidCloseTextDocumentParams (TextDocumentIdentifier (docId ^. uri))
sendNotification TextDocumentDidClose params
- oldVfs <- vfs <$> get
- let notif = NotificationMessage "" TextDocumentDidClose params
- newVfs <- liftIO $ closeVFS oldVfs notif
- modify $ \s -> s { vfs = newVfs }
+-- | Changes a text document and sends a notification to the client
+changeDoc :: TextDocumentIdentifier -> [TextDocumentContentChangeEvent] -> Session ()
+changeDoc docId changes = do
+ verDoc <- getVersionedDoc docId
+ let params = DidChangeTextDocumentParams (verDoc & version . non 0 +~ 1) (List changes)
+ sendNotification TextDocumentDidChange params
-- | Gets the Uri for the file corrected to the session directory.
getDocUri :: FilePath -> Session Uri
-- | Returns the symbols in a document.
getDocumentSymbols :: TextDocumentIdentifier -> Session (Either [DocumentSymbol] [SymbolInformation])
getDocumentSymbols doc = do
- ResponseMessage _ rspLid mRes mErr <- request TextDocumentDocumentSymbol (DocumentSymbolParams doc) :: Session DocumentSymbolsResponse
+ ResponseMessage _ rspLid mRes mErr <- request TextDocumentDocumentSymbol (DocumentSymbolParams doc Nothing) :: Session DocumentSymbolsResponse
maybe (return ()) (throw . UnexpectedResponseError rspLid) mErr
case mRes of
Just (DSDocumentSymbols (List xs)) -> return (Left xs)
getCodeActions :: TextDocumentIdentifier -> Range -> Session [CAResult]
getCodeActions doc range = do
ctx <- getCodeActionContext doc
- rsp <- request TextDocumentCodeAction (CodeActionParams doc range ctx)
+ rsp <- request TextDocumentCodeAction (CodeActionParams doc range ctx Nothing)
case rsp ^. result of
Just (List xs) -> return xs
where
go :: CodeActionContext -> [CAResult] -> Diagnostic -> Session [CAResult]
go ctx acc diag = do
- ResponseMessage _ rspLid mRes mErr <- request TextDocumentCodeAction (CodeActionParams doc (diag ^. range) ctx)
+ ResponseMessage _ rspLid mRes mErr <- request TextDocumentCodeAction (CodeActionParams doc (diag ^. range) ctx Nothing)
case mErr of
Just e -> throw (UnexpectedResponseError rspLid e)
-- | Returns the current diagnostics that have been sent to the client.
-- Note that this does not wait for more to come in.
getCurrentDiagnostics :: TextDocumentIdentifier -> Session [Diagnostic]
-getCurrentDiagnostics doc = fromMaybe [] . Map.lookup (doc ^. uri) . curDiagnostics <$> get
+getCurrentDiagnostics doc = fromMaybe [] . Map.lookup (toNormalizedUri $ doc ^. uri) . curDiagnostics <$> get
-- | Executes a command.
executeCommand :: Command -> Session ()
executeCommand cmd = do
let args = decode $ encode $ fromJust $ cmd ^. arguments
- execParams = ExecuteCommandParams (cmd ^. command) args
+ execParams = ExecuteCommandParams (cmd ^. command) args Nothing
request_ WorkspaceExecuteCommand execParams
-- | Executes a code action.
-- | Adds the current version to the document, as tracked by the session.
getVersionedDoc :: TextDocumentIdentifier -> Session VersionedTextDocumentIdentifier
getVersionedDoc (TextDocumentIdentifier uri) = do
- fs <- vfs <$> get
+ fs <- vfsMap . vfs <$> get
let ver =
- case fs Map.!? uri of
- Just (VirtualFile v _) -> Just v
+ case fs Map.!? toNormalizedUri uri of
+ Just vf -> Just (virtualFileVersion vf)
_ -> Nothing
return (VersionedTextDocumentIdentifier uri ver)
-- | Returns the completions for the position in the document.
getCompletions :: TextDocumentIdentifier -> Position -> Session [CompletionItem]
getCompletions doc pos = do
- rsp <- request TextDocumentCompletion (TextDocumentPositionParams doc pos)
+ rsp <- request TextDocumentCompletion (TextDocumentPositionParams doc pos Nothing)
case getResponseResult rsp of
Completions (List items) -> return items
-> Session [Location] -- ^ The locations of the references.
getReferences doc pos inclDecl =
let ctx = ReferenceContext inclDecl
- params = ReferenceParams doc pos ctx
+ params = ReferenceParams doc pos ctx Nothing
in getResponseResult <$> request TextDocumentReferences params
-- | Returns the definition(s) for the term at the specified position.
getDefinitions :: TextDocumentIdentifier -- ^ The document the term is in.
-> Position -- ^ The position the term is at.
-> Session [Location] -- ^ The location(s) of the definitions
-getDefinitions doc pos =
- let params = TextDocumentPositionParams doc pos
- in getResponseResult <$> request TextDocumentDefinition params
+getDefinitions doc pos = do
+ let params = TextDocumentPositionParams doc pos Nothing
+ rsp <- request TextDocumentDefinition params :: Session DefinitionResponse
+ case getResponseResult rsp of
+ SingleLoc loc -> pure [loc]
+ MultiLoc locs -> pure locs
-- | Returns the type definition(s) for the term at the specified position.
getTypeDefinitions :: TextDocumentIdentifier -- ^ The document the term is in.
-> Position -- ^ The position the term is at.
-> Session [Location] -- ^ The location(s) of the definitions
getTypeDefinitions doc pos =
- let params = TextDocumentPositionParams doc pos
+ let params = TextDocumentPositionParams doc pos Nothing
in getResponseResult <$> request TextDocumentTypeDefinition params
-- | Renames the term at the specified position.
rename :: TextDocumentIdentifier -> Position -> String -> Session ()
rename doc pos newName = do
- let params = RenameParams doc pos (T.pack newName)
+ let params = RenameParams doc pos (T.pack newName) Nothing
rsp <- request TextDocumentRename params :: Session RenameResponse
let wEdit = getResponseResult rsp
req = RequestMessage "" (IdInt 0) WorkspaceApplyEdit (ApplyWorkspaceEditParams wEdit)
-- | Returns the hover information at the specified position.
getHover :: TextDocumentIdentifier -> Position -> Session (Maybe Hover)
getHover doc pos =
- let params = TextDocumentPositionParams doc pos
+ let params = TextDocumentPositionParams doc pos Nothing
in getResponseResult <$> request TextDocumentHover params
-- | Returns the highlighted occurences of the term at the specified position
getHighlights :: TextDocumentIdentifier -> Position -> Session [DocumentHighlight]
getHighlights doc pos =
- let params = TextDocumentPositionParams doc pos
+ let params = TextDocumentPositionParams doc pos Nothing
in getResponseResult <$> request TextDocumentDocumentHighlight params
-- | Checks the response for errors and throws an exception if needed.
-- | Applies formatting to the specified document.
formatDoc :: TextDocumentIdentifier -> FormattingOptions -> Session ()
formatDoc doc opts = do
- let params = DocumentFormattingParams doc opts
+ let params = DocumentFormattingParams doc opts Nothing
edits <- getResponseResult <$> request TextDocumentFormatting params
applyTextEdits doc edits
-- | Applies formatting to the specified range in a document.
formatRange :: TextDocumentIdentifier -> FormattingOptions -> Range -> Session ()
formatRange doc opts range = do
- let params = DocumentRangeFormattingParams doc range opts
+ let params = DocumentRangeFormattingParams doc range opts Nothing
edits <- getResponseResult <$> request TextDocumentRangeFormatting params
applyTextEdits doc edits
let wEdit = WorkspaceEdit (Just (HashMap.singleton (doc ^. uri) edits)) Nothing
req = RequestMessage "" (IdInt 0) WorkspaceApplyEdit (ApplyWorkspaceEditParams wEdit)
in updateState (ReqApplyWorkspaceEdit req)
+
+-- | Returns the code lenses for the specified document.
+getCodeLenses :: TextDocumentIdentifier -> Session [CodeLens]
+getCodeLenses tId = do
+ rsp <- request TextDocumentCodeLens (CodeLensParams tId Nothing) :: Session CodeLensResponse
+ case getResponseResult rsp of
+ List res -> pure res